How to Monitor a Java Application with Prometheus and Grafana

To monitor a Java application with Prometheus and Grafana, first instrument the app using Micrometer by adding micrometer-registry-prometheus and Spring Boot Actuator dependencies, then expose the /actuator/prometheus endpoint via configuration in application.yml. 2. Set up Prometheus by downloading it, configuring the prometheus.yml file to scrape the Java app’s metrics endpoint at /actuator/prometheus from target localhost:8080, and starting Prometheus to confirm metric collection via the expression browser. 3. Install Grafana, add Prometheus as a data source pointing to http://localhost:9090, and import a prebuilt dashboard such as ID 4701 or 12554 to visualize JVM and Spring Boot metrics including memory, garbage collection, threads, HTTP latency, and CPU usage. 4. Optionally, add custom business metrics using Micrometer’s MeterRegistry to create counters, timers, or gauges that can be queried in Prometheus and displayed in Grafana. 5. Ensure the Prometheus scraper can access the actuator endpoint, secure sensitive endpoints in production, and manage metric label cardinality to maintain performance. This setup provides a scalable, vendor-neutral observability solution for Java applications.

Monitoring a Java application with Prometheus and Grafana gives you real-time visibility into performance metrics like CPU usage, memory, garbage collection, and custom business logic. Setting this up involves instrumenting your Java app to expose metrics, configuring Prometheus to scrape them, and visualizing the data in Grafana. Here’s how to do it step by step.

1. Instrument Your Java Application with Micrometer

Micrometer is the standard library for exposing metrics in Java apps, especially with Spring Boot. It acts as a facade to various monitoring systems, including Prometheus.

Step 1: Add Dependencies

If you're using Maven, add these to your pom.xml:

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-core</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

For Spring Boot 2.3 , just adding micrometer-registry-prometheus is enough — it auto-configures everything.

Step 2: Expose Metrics Endpoint

Micrometer automatically configures a /actuator/prometheus endpoint when:

• You have Spring Boot Actuator enabled
• The Prometheus registry is on the classpath

Add this to application.yml:

management:
  endpoints:
    web:
      exposure:
        include: health,info,prometheus,metrics

Now when you run your app, visit http://localhost:8080/actuator/prometheus — you should see raw metrics in Prometheus format.

2. Set Up Prometheus

Prometheus will scrape metrics from your Java app at regular intervals.

Step 1: Download and Install Prometheus

Get Prometheus from prometheus.io/download.

Step 2: Configure prometheus.yml

Edit the config file to add your Java app as a scrape target:

scrape_configs:
  - job_name: 'java-app'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['localhost:8080']

Make sure the target matches your app’s host and port.

Step 3: Start Prometheus

Run:

./prometheus --config.file=prometheus.yml

Go to http://localhost:9090 to access the Prometheus UI. Use the expression browser to test queries like:

jvm_memory_used_bytes

You should see live data from your app.

3. Visualize Metrics in Grafana

Grafana turns raw metrics into dashboards.

Step 1: Install and Run Grafana

Download from grafana.com, or use Docker:

docker run -d -p 3000:3000 --name=grafana grafana/grafana

Step 2: Add Prometheus as a Data Source

• Open http://localhost:3000 (default login: admin/admin)
• Go to Configuration > Data Sources > Add data source
• Choose Prometheus
• Set URL to http://host.docker.internal:9090 (or http://localhost:9090 if not in Docker)
• Save & test

Step 3: Import a Java Monitoring Dashboard

Use a prebuilt dashboard for JVM metrics:

• Go to Create > Import
• Enter dashboard ID 4701 (JVM (Micrometer)) or 12554 (Spring Boot Application)
• Select your Prometheus data source
• Click Import

You’ll now see graphs for:

• Heap and non-heap memory
• Garbage collection time and count
• Thread count
• HTTP request latency
• CPU usage

4. Add Custom Metrics (Optional)

You can track business-specific metrics using Micrometer.

Example: Counting successful orders

@Autowired
private MeterRegistry registry;

public void onOrderProcessed() {
    Counter counter = registry.counter("app.orders.success");
    counter.increment();
}

This creates a metric called app_orders_success_total, which you can query in Prometheus and display in Grafana.

You can also use timers, gauges, and distribution summaries for more complex tracking.

Final Notes

• Make sure your app’s /actuator/prometheus endpoint is accessible from Prometheus (watch out for firewalls or Docker networks).
• For production, secure your actuator endpoints (management.endpoints.web.exposure.include should not expose sensitive endpoints publicly).
• Use labels wisely — they increase cardinality, which can impact Prometheus performance.

Basically, with Micrometer Prometheus Grafana, you get a powerful, open-source observability stack for Java apps — no vendor lock-in, and it scales well.

The above is the detailed content of How to Monitor a Java Application with Prometheus and Grafana. For more information, please follow other related articles on the PHP Chinese website!