Chapitre 3: Métriques avec Micrometer
Introduction
Micrometer est la bibliothèque de métriques de Spring Boot. Elle fournit une façade qui s'adapte à différents systèmes de monitoring (Prometheus, Datadog, InfluxDB, etc.).
🎯 Objectifs du Chapitre
À la fin de ce chapitre, vous saurez:
- ✅ Comprendre les types de métriques
- ✅ Utiliser les métriques natives
- ✅ Créer des métriques personnalisées
- ✅ Ajouter des tags pour le filtrage
- ✅ Configurer l'export vers Prometheus
1. Introduction à Micrometer
Architecture
Votre Application
↓
Micrometer (Façade)
↓
┌─────┴─────┐
│ Registres │
├────────────┤
│ Prometheus │
│ Datadog │
│ InfluxDB │
│ CloudWatch │
└────────────┘
Dépendance Prometheus
<dependency>
<groupId>io.micrometer</groupId>
<artifactId>micrometer-registry-prometheus</artifactId>
</dependency>
2. Types de Métriques
Counter (Compteur)
Valeur qui ne fait qu'augmenter:
@Service
@RequiredArgsConstructor
public class OrderService {
private final Counter ordersCreated;
public OrderService(MeterRegistry registry) {
this.ordersCreated = Counter.builder("orders.created")
.description("Number of orders created")
.register(registry);
}
public Order createOrder(OrderRequest request) {
Order order = processOrder(request);
ordersCreated.increment(); // +1
return order;
}
}
Usages: Nombre de requêtes, erreurs, événements.
Gauge (Jauge)
Valeur instantanée qui peut monter ou descendre:
@Component
public class QueueMetrics {
private final Queue<Task> taskQueue;
public QueueMetrics(MeterRegistry registry, Queue<Task> taskQueue) {
this.taskQueue = taskQueue;
Gauge.builder("tasks.queue.size", taskQueue, Queue::size)
.description("Current number of tasks in queue")
.register(registry);
}
}
Usages: Mémoire utilisée, connexions actives, taille de file.
Timer (Chronomètre)
Mesure la durée et le nombre d'appels:
@Service
public class PaymentService {
private final Timer paymentTimer;
public PaymentService(MeterRegistry registry) {
this.paymentTimer = Timer.builder("payment.process.time")
.description("Time to process payments")
.register(registry);
}
public Payment process(PaymentRequest request) {
return paymentTimer.record(() -> {
// Le temps est mesuré automatiquement
return executePayment(request);
});
}
}
Avec annotation @Timed:
@Service
public class ProductService {
@Timed(value = "product.search.time", description = "Time to search products")
public List<Product> search(String query) {
return productRepository.search(query);
}
}
Activer @Timed:
@Configuration
public class MetricsConfig {
@Bean
public TimedAspect timedAspect(MeterRegistry registry) {
return new TimedAspect(registry);
}
}
Summary (Distribution)
Statistiques de distribution (percentiles):
@Service
public class OrderService {
private final DistributionSummary orderAmount;
public OrderService(MeterRegistry registry) {
this.orderAmount = DistributionSummary.builder("order.amount")
.description("Order amounts")
.baseUnit("dollars")
.publishPercentiles(0.5, 0.95, 0.99) // Médiane, P95, P99
.register(registry);
}
public Order createOrder(Order order) {
orderAmount.record(order.getTotal().doubleValue());
return orderRepository.save(order);
}
}
3. Métriques Natives
Spring Boot expose automatiquement de nombreuses métriques:
Métriques JVM
# Mémoire
curl http://localhost:8080/actuator/metrics/jvm.memory.used
curl http://localhost:8080/actuator/metrics/jvm.memory.max
# Threads
curl http://localhost:8080/actuator/metrics/jvm.threads.live
# Garbage Collection
curl http://localhost:8080/actuator/metrics/jvm.gc.pause
Métriques HTTP
# Requêtes HTTP
curl http://localhost:8080/actuator/metrics/http.server.requests
# Avec filtrage par tag
curl "http://localhost:8080/actuator/metrics/http.server.requests?tag=uri:/api/users"
curl "http://localhost:8080/actuator/metrics/http.server.requests?tag=status:200"
Métriques Base de Données
# HikariCP
curl http://localhost:8080/actuator/metrics/hikaricp.connections.active
curl http://localhost:8080/actuator/metrics/hikaricp.connections.idle
curl http://localhost:8080/actuator/metrics/hikaricp.connections.pending
Liste Complète
curl http://localhost:8080/actuator/metrics
{
"names": [
"jvm.memory.used",
"jvm.memory.max",
"jvm.threads.live",
"jvm.gc.pause",
"http.server.requests",
"hikaricp.connections.active",
"logback.events",
"process.cpu.usage",
"system.cpu.usage"
]
}
4. Métriques Personnalisées
Avec MeterRegistry
@Service
@RequiredArgsConstructor
public class UserService {
private final MeterRegistry meterRegistry;
private final UserRepository userRepository;
public User register(UserRequest request) {
User user = createUser(request);
// Incrémenter un counter avec tags
meterRegistry.counter("users.registered",
"type", request.getType(),
"country", request.getCountry()
).increment();
return user;
}
public void login(String username) {
// Timer inline
meterRegistry.timer("user.login.time").record(() -> {
performLogin(username);
});
meterRegistry.counter("user.logins").increment();
}
}
Avec @Counted et @Timed
@Service
public class NotificationService {
@Counted(value = "notifications.sent", description = "Number of notifications sent")
public void sendNotification(Notification notification) {
// Envoi...
}
@Timed(value = "notifications.process.time", percentiles = {0.5, 0.95, 0.99})
public void processNotifications() {
// Traitement...
}
}
Exemple Complet: Métriques Métier
@Component
@RequiredArgsConstructor
public class BusinessMetrics {
private final MeterRegistry registry;
private final OrderRepository orderRepository;
private Counter ordersCreated;
private Counter ordersFailed;
private Timer orderProcessingTime;
private AtomicInteger activeOrders;
@PostConstruct
public void init() {
// Counters
ordersCreated = Counter.builder("business.orders.created")
.description("Total orders created")
.register(registry);
ordersFailed = Counter.builder("business.orders.failed")
.description("Total orders failed")
.register(registry);
// Timer
orderProcessingTime = Timer.builder("business.orders.processing.time")
.description("Order processing time")
.publishPercentiles(0.5, 0.95, 0.99)
.register(registry);
// Gauge (valeur dynamique)
activeOrders = new AtomicInteger(0);
Gauge.builder("business.orders.active", activeOrders, AtomicInteger::get)
.description("Currently active orders")
.register(registry);
// Gauge basé sur une requête DB
Gauge.builder("business.orders.pending", orderRepository,
repo -> repo.countByStatus(OrderStatus.PENDING))
.description("Pending orders in database")
.register(registry);
}
public void recordOrderCreated(String type) {
ordersCreated.increment();
registry.counter("business.orders.created.by.type", "type", type).increment();
}
public void recordOrderFailed(String reason) {
ordersFailed.increment();
registry.counter("business.orders.failed.by.reason", "reason", reason).increment();
}
public void recordProcessingTime(Runnable operation) {
orderProcessingTime.record(operation);
}
public void incrementActiveOrders() {
activeOrders.incrementAndGet();
}
public void decrementActiveOrders() {
activeOrders.decrementAndGet();
}
}
5. Tags et Dimensions
Importance des Tags
Les tags permettent de filtrer et grouper les métriques:
// Sans tags: une seule valeur globale
meterRegistry.counter("http.requests").increment();
// Avec tags: filtrable par méthode, status, uri
meterRegistry.counter("http.requests",
"method", "GET",
"status", "200",
"uri", "/api/users"
).increment();
Tags Communs (globaux)
@Configuration
public class MetricsConfig {
@Bean
public MeterRegistryCustomizer<MeterRegistry> commonTags() {
return registry -> registry.config()
.commonTags(
"application", "my-app",
"environment", "production",
"region", "us-east-1"
);
}
}
Bonnes Pratiques Tags
// ✅ BON: Cardinalité faible
meterRegistry.counter("orders", "status", "COMPLETED"); // ~5 valeurs possibles
meterRegistry.counter("orders", "type", "STANDARD"); // ~3 valeurs possibles
// ❌ MAUVAIS: Cardinalité haute (explosion de séries)
meterRegistry.counter("orders", "orderId", order.getId()); // Millions de valeurs!
meterRegistry.counter("users", "email", user.getEmail()); // Unique par user!
6. Export Prometheus
Configuration
# application.properties
management.endpoints.web.exposure.include=prometheus,health,metrics
management.prometheus.metrics.export.enabled=true
Format Prometheus
curl http://localhost:8080/actuator/prometheus
# HELP jvm_memory_used_bytes The amount of used memory
# TYPE jvm_memory_used_bytes gauge
jvm_memory_used_bytes{area="heap",id="G1 Eden Space",} 1.048576E7
jvm_memory_used_bytes{area="heap",id="G1 Old Gen",} 2.097152E7
# HELP http_server_requests_seconds
# TYPE http_server_requests_seconds summary
http_server_requests_seconds_count{method="GET",status="200",uri="/api/users",} 150.0
http_server_requests_seconds_sum{method="GET",status="200",uri="/api/users",} 12.5
# HELP orders_created_total Number of orders created
# TYPE orders_created_total counter
orders_created_total{type="STANDARD",} 1523.0
orders_created_total{type="EXPRESS",} 342.0
7. Résumé
Types de Métriques
| Type | Usage | Exemple |
|---|---|---|
| Counter | Compte des événements | Requêtes, erreurs |
| Gauge | Valeur instantanée | Mémoire, connexions actives |
| Timer | Durée + count | Temps de réponse |
| Summary | Distribution | Percentiles |
Création de Métriques
// Counter
meterRegistry.counter("my.counter", "tag", "value").increment();
// Timer
meterRegistry.timer("my.timer").record(() -> operation());
// Gauge
Gauge.builder("my.gauge", obj, Object::getValue).register(registry);
Annotations
@Timed("method.time")
@Counted("method.calls")
public void myMethod() { }
🎯 Prochaine Étape
Les métriques c'est pour mesurer. Mais comment savoir si l'application est saine? Place aux Health Checks!