Prometheus Monitoring for Spring Boot Actuator

The Monitoring Stack at a Glance

We will be working with three core components:

1. Spring Boot Actuator: A Spring Boot sub-project that exposes operational information about your running application—health, metrics, environment info, and more—through a set of endpoints.
2. Prometheus: An open-source monitoring and alerting toolkit. Its primary job is to periodically "scrape" (collect) metrics from configured endpoints, store them in a time-series database, and allow you to query them.
3. Grafana: An open-source visualization tool. It connects to data sources like Prometheus to create rich, interactive dashboards, turning raw metrics into meaningful graphs and alerts.

Let's get started.

1. Exposing Metrics with Spring Boot Actuator

Our first step is to configure our Spring Boot application to produce metrics in a format that Prometheus can understand. This is achieved by combining Spring Boot Actuator with the Micrometer library. Micrometer acts as a metrics facade, similar to how SLF4J is a facade for logging, allowing you to instrument your code with metrics and decide at runtime which monitoring system to send them to.

After following the guide, your pom.xml should include these dependencies:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

And your application.yml should be configured to expose the Prometheus endpoint:

management:
  endpoints:
    web:
      exposure:
        include: "prometheus,health,info" # Exposing prometheus and other useful endpoints

Now, if you run your Spring Boot application and navigate to http://localhost:8080/actuator/prometheus, you will see a text-based response. This is not meant for human eyes! It's a snapshot of all the current metrics of your application, formatted for the Prometheus scraper to consume. You'll see metrics for the JVM (memory, garbage collection), your web server (active threads), HTTP request latencies, and more.

2. Setting Up the Monitoring Stack with Docker Compose

Now that our application is exposing metrics, we need to set up Prometheus to collect them and Grafana to visualize them. Since you're familiar with Docker from our previous module, we'll use Docker Compose to spin up this entire stack with a single command.

We need two configuration files:

1. docker-compose.yml: Defines the Prometheus and Grafana services.
2. prometheus.yml: Configures Prometheus, telling it where to find and scrape metrics from our Spring Boot application.

Create a new directory for these files, for example, monitoring.

1. docker-compose.yml
Create a file named docker-compose.yml with the following content:

version: '3.7'

services:
  prometheus:
    image: prom/prometheus:v2.44.0
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'

  grafana:
    image: grafana/grafana:9.5.2
    container_name: grafana
    ports:
      - "3000:3000"
    restart: unless-stopped

This file defines two services: prometheus running on port 9090 and grafana on port 3000. It mounts our local prometheus.yml configuration file into the Prometheus container.

2. prometheus.yml
Create a file named prometheus.yml in the same directory:

global:
  scrape_interval: 15s # How frequently to scrape targets

scrape_configs:
  - job_name: 'spring-boot-app'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['host.docker.internal:8080']

This is the key configuration. It tells Prometheus to:

• Create a job named spring-boot-app.
• Scrape the /actuator/prometheus path on its targets every 15 seconds.
• The target is host.docker.internal:8080. host.docker.internal is a special DNS name that resolves to the IP address of your host machine from within a Docker container. This allows the Prometheus container to reach your Spring Boot application running on localhost:8080.

With your Spring Boot application running locally, navigate to your monitoring directory in the terminal and run:

docker-compose up -d

This will download and start the Prometheus and Grafana containers in the background.

3. Visualizing Metrics: From Raw Data to Insight

Your full monitoring stack is now running! Let's explore it.

Exploring the Prometheus UI

First, let's verify that Prometheus is successfully collecting data from our application.

1. Open your browser and go to http://localhost:9090.
2. Navigate to Status > Targets from the top menu.
3. You should see your spring-boot-app job with a single endpoint. If the "State" is UP, congratulations! Prometheus is successfully scraping your application.

Creating Dashboards in Grafana

While Prometheus is great at collecting and storing data, its UI is primarily for diagnostics and querying. For visualization, we turn to Grafana.

By importing a community dashboard, you instantly get a rich visualization of your application's performance, including:

• JVM Health: Heap memory usage, garbage collection frequency and duration, thread count.
• HTTP Server Performance: Request rate, error rate, and response times.
• System Metrics: CPU and memory usage of the process.

Conclusion

Congratulations on completing the final lesson! You have now set up a complete observability stack for your Spring Boot application, a skill that is absolutely essential for running reliable services in production.

Key Takeaways:

• Observability is critical: Once an application is deployed, you need tools to monitor its health and performance.
• Actuator + Micrometer: This combination is the standard way to expose application metrics from a Spring Boot application.
• Prometheus scrapes metrics: Prometheus operates on a pull model, periodically collecting data from configured endpoints.
• Grafana visualizes data: Grafana connects to data sources like Prometheus to build powerful, insightful dashboards.
• Docker Compose simplifies local setup: It's the perfect tool for running your entire monitoring stack (and other services) for local development and testing.

Your Journey as a Backend Developer

You've come a long way. You started with the fundamental building blocks of Java web development, mastered the Spring Framework to build robust REST APIs, integrated databases, secured your endpoints, wrote comprehensive tests, and finally, learned to containerize, deploy, and monitor your application using a modern CI/CD pipeline.

You now possess a solid, end-to-end skill set that forms the foundation of modern backend engineering. The journey doesn't end here. Continue to build projects, explore advanced topics like distributed tracing, delve deeper into cloud-native patterns, and never stop learning. You are well-equipped for the challenges ahead. Well done