Monitoring with Spring Boot Actuator

1. The Metrics Endpoint and the Role of Micrometer

Just like the other Actuator endpoints, the metrics endpoint is enabled by adding the spring-boot-starter-actuator dependency. As you learned previously, most endpoints are not exposed over HTTP by default. To start, let's expose the metrics endpoint in your application.properties file:

management.endpoints.web.exposure.include=health,info,metrics

Once you restart your application, you can navigate to /actuator/metrics to see a list of all available metric names.

The following video provides a clear, practical demonstration of enabling the metrics endpoint and exploring the data it provides.

You might be wondering where all this metric-gathering capability comes from. Spring Boot uses a powerful library called Micrometer. Think of Micrometer as the "SLF4J for metrics." Just as SLF4J provides a standard logging API that can be backed by different logging implementations (like Logback or Log4j), Micrometer provides a standard API for collecting metrics that can be exported to dozens of different monitoring systems.

This abstraction is incredibly powerful. You instrument your code once using the Micrometer API, and then you can switch between monitoring backends like Prometheus, Datadog, or New Relic just by changing a dependency and some configuration.

To better understand the core concepts behind Micrometer, the following article explains the different types of "meters" used to measure application behavior.

2. Exploring Built-in Metrics

Spring Boot's auto-configuration automatically registers a wide array of useful metrics for you. Without writing any code, you get deep insights into the JVM, the underlying system, your web server, and more.

The official Spring Boot documentation provides a comprehensive list of all auto-configured instrumentation.

The ability to filter by tags (/actuator/metrics/http.server.requests?tag=uri:/my-endpoint&tag=status:200) is crucial for isolating specific behaviors in your system, which is a common task when troubleshooting or optimizing microservices.

3. Integrating with Prometheus and Grafana

While the /actuator/metrics endpoint is great for quick diagnostics, it's not designed for long-term storage or advanced analysis. For production monitoring, you need to ship these metrics to a dedicated monitoring system. One of the most common stacks for this in the world of microservices is Prometheus for data collection and storage, and Grafana for visualization.

Thanks to Micrometer, configuring our application to expose metrics in a format that Prometheus can understand is straightforward.

1. Add the Prometheus Registry Dependency: Add the following to your pom.xml. This brings in the necessary adapter that translates Micrometer metrics into the Prometheus exposition format.

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

2. Expose the Prometheus Endpoint: Update your application.properties to expose the new /actuator/prometheus endpoint.

   management.endpoints.web.exposure.include=health,info,metrics,prometheus
   

After restarting, you can access /actuator/prometheus and you'll see your application's metrics rendered in a text-based format that Prometheus is designed to scrape.

The following video explains this integration and provides the necessary context on how Prometheus works.

4. Hands-On: Visualizing Metrics in Grafana

Now let's put it all together. The same video provides a docker-compose.yml file to spin up Prometheus and Grafana. By following along, you can build a complete, local monitoring environment to visualize the metrics from your Spring Boot application.

Once you've completed this, you'll have a dashboard similar to this, showing live data from your running application.

5. Creating Custom Application Metrics

System-level metrics are essential, but the real power of monitoring comes from creating metrics that are specific to your business domain. For example, you might want to count the number of orders placed, measure the time it takes to process a payment, or track the number of active user sessions.

You can create custom metrics by injecting the MeterRegistry into your Spring beans and using it to create and update meters.

Here's a simple example of creating a custom counter:

import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    private final Counter ordersPlacedCounter;

    public OrderService(MeterRegistry meterRegistry) {
        // Create a counter. The name, description, and tags are used
        // to identify the metric in the monitoring system.
        this.ordersPlacedCounter = Counter.builder("orders.placed")
                .description("The number of orders placed.")
                .tag("region", "us-east") // Example tag
                .register(meterRegistry);
    }

    public void placeOrder() {
        // Business logic for placing an order...
        
        // Increment the counter each time an order is placed.
        this.ordersPlacedCounter.increment();
    }
}

This simple pattern allows you to instrument any part of your application and gain quantitative insights into its business-level operations.

Conclusion

Congratulations on completing the final lesson! You have now journeyed from the fundamentals of Java for Spring, through dependency injection and REST APIs, all the way to containerizing and monitoring your application.

Key Takeaways from this Lesson:

• Spring Boot Actuator uses Micrometer as a facade to provide a rich set of application metrics.
• The /actuator/metrics endpoint allows for diagnostic inspection, while the /actuator/prometheus endpoint exposes data for external monitoring systems.
• A vast array of built-in metrics for the JVM, system, web server, and more are available with zero configuration.
• For production use, you should integrate with a time-series database like Prometheus and a visualization tool like Grafana.
• You can create custom, business-specific metrics by injecting the MeterRegistry and creating Counters, Timers, or Gauges.

You have successfully covered all the learning outcomes for this course. With the knowledge you've gained, you now have a solid foundation to build, package, and operate robust microservices and web applications using the Spring ecosystem. Well done