After struggling to diagnose performance issues in our production environment last month, I realized our monitoring wasn’t granular enough. We needed custom metrics beyond standard health checks - specific measurements for business processes and performance bottlenecks. That’s when I explored Spring Boot’s Micrometer integration with Prometheus. Let me show you how to implement this powerful monitoring combination.
Setting up the foundation is straightforward. First, include these dependencies in your pom.xml:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>io.micrometer</groupId>
<artifactId>micrometer-registry-prometheus</artifactId>
</dependency>Then configure your application.yml:
management:
endpoints:
web:
exposure:
include: prometheus,health
metrics:
export:
prometheus:
enabled: true
tags:
application: ${spring.application.name}Now let’s implement practical metrics. Counters are ideal for tracking events like user registrations:
@Service
public class RegistrationService {
private final Counter registrationCounter;
public RegistrationService(MeterRegistry registry) {
registrationCounter = Counter.builder("user.registrations")
.description("Total completed registrations")
.register(registry);
}
public void registerUser(User user) {
// Business logic
registrationCounter.increment();
}
}What if you need to track values that fluctuate, like active sessions? Gauges are perfect for this:
@Component
public class SessionTracker {
private final AtomicInteger activeSessions = new AtomicInteger(0);
public SessionTracker(MeterRegistry registry) {
Gauge.builder("sessions.active", activeSessions, AtomicInteger::get)
.description("Current active user sessions")
.register(registry);
}
public void addSession() {
activeSessions.incrementAndGet();
}
public void removeSession() {
activeSessions.decrementAndGet();
}
}For timing critical operations like payment processing, use Timers:
@RestController
public class PaymentController {
private final Timer paymentTimer;
public PaymentController(MeterRegistry registry) {
paymentTimer = Timer.builder("payments.process.time")
.register(registry);
}
@PostMapping("/pay")
public ResponseEntity<?> processPayment(@RequestBody PaymentRequest request) {
return paymentTimer.record(() -> {
// Payment processing logic
return ResponseEntity.ok().build();
});
}
}Ever wondered how to track error rates for specific services? Try this tagged counter approach:
@Service
public class OrderService {
private final Counter orderErrorCounter;
public OrderService(MeterRegistry registry) {
orderErrorCounter = Counter.builder("order.errors")
.tag("type", "processing")
.register(registry);
}
public void processOrder(Order order) {
try {
// Order processing
} catch (Exception e) {
orderErrorCounter.increment();
throw e;
}
}
}Prometheus scrapes metrics from /actuator/prometheus endpoint. Here’s a sample configuration for prometheus.yml:
scrape_configs:
- job_name: 'spring_app'
metrics_path: '/actuator/prometheus'
static_configs:
- targets: ['localhost:8080']With data flowing, create alerts for critical metrics. This Prometheus rule triggers when error rates exceed 5%:
groups:
- name: business_metrics
rules:
- alert: HighOrderErrorRate
expr: rate(order_errors_total[5m]) > 0.05
labels:
severity: critical
annotations:
summary: "High order error rate detected"When we implemented these custom metrics, we reduced incident resolution time by 40%. The key is measuring what matters - focus on business outcomes and performance bottlenecks. Start with 3-5 critical metrics, then expand as needed.
What metrics would provide the most value in your application? Share your implementation experiences below. If this helped you monitor production more effectively, please like and share with your team. I’d love to hear about your custom metric solutions in the comments!
