Capítulo 3: Métricas com Micrometer
Introdução
Micrometer é a biblioteca de métricas do Spring Boot. Ela fornece uma fachada que se adapta a diferentes sistemas de monitoramento (Prometheus, Datadog, InfluxDB, etc.).
🎯 Objetivos do Capítulo
Ao final deste capítulo, você saberá:
- ✅ Compreender os tipos de métricas
- ✅ Utilizar as métricas nativas
- ✅ Criar métricas personalizadas
- ✅ Adicionar tags para filtragem
- ✅ Configurar exportação para Prometheus
1. Introdução ao Micrometer
Arquitetura
Sua Aplicação
↓
Micrometer (Fachada)
↓
┌─────┴─────┐
│ Registries │
├────────────┤
│ Prometheus │
│ Datadog │
│ InfluxDB │
│ CloudWatch │
└────────────┘
Dependência Prometheus
<dependency>
<groupId>io.micrometer</groupId>
<artifactId>micrometer-registry-prometheus</artifactId>
</dependency>
2. Tipos de Métricas
Counter (Contador)
Valor que só aumenta:
@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;
}
}
Usos: Número de requisições, erros, eventos.
Gauge (Medidor)
Valor instantâneo que pode subir ou descer:
@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);
}
}
Usos: Memória utilizada, conexões ativas, tamanho de fila.
Timer (Cronômetro)
Mede a duração e o número de chamadas:
@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(() -> {
// O tempo é medido automaticamente
return executePayment(request);
});
}
}
Com anotação @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);
}
}
Ativar @Timed:
@Configuration
public class MetricsConfig {
@Bean
public TimedAspect timedAspect(MeterRegistry registry) {
return new TimedAspect(registry);
}
}
Summary (Distribuição)
Estatísticas de distribuição (percentis):
@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) // Mediana, P95, P99
.register(registry);
}
public Order createOrder(Order order) {
orderAmount.record(order.getTotal().doubleValue());
return orderRepository.save(order);
}
}
3. Métricas Nativas
Spring Boot expõe automaticamente várias métricas:
Métricas JVM
# Memória
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étricas HTTP
# Requisições HTTP
curl http://localhost:8080/actuator/metrics/http.server.requests
# Com filtragem por 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étricas de Banco de Dados
# 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
Lista Completa
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étricas Personalizadas
Com MeterRegistry
@Service
@RequiredArgsConstructor
public class UserService {
private final MeterRegistry meterRegistry;
private final UserRepository userRepository;
public User register(UserRequest request) {
User user = createUser(request);
// Incrementar um counter com 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();
}
}
Com @Counted e @Timed
@Service
public class NotificationService {
@Counted(value = "notifications.sent", description = "Number of notifications sent")
public void sendNotification(Notification notification) {
// Envio...
}
@Timed(value = "notifications.process.time", percentiles = {0.5, 0.95, 0.99})
public void processNotifications() {
// Processamento...
}
}
Exemplo Completo: Métricas de Negócio
@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 (valor dinâmico)
activeOrders = new AtomicInteger(0);
Gauge.builder("business.orders.active", activeOrders, AtomicInteger::get)
.description("Currently active orders")
.register(registry);
// Gauge baseado em uma consulta ao banco
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 e Dimensões
Importância dos Tags
Os tags permitem filtrar e agrupar as métricas:
// Sem tags: um único valor global
meterRegistry.counter("http.requests").increment();
// Com tags: filtrável por método, status, uri
meterRegistry.counter("http.requests",
"method", "GET",
"status", "200",
"uri", "/api/users"
).increment();
Tags Comuns (globais)
@Configuration
public class MetricsConfig {
@Bean
public MeterRegistryCustomizer<MeterRegistry> commonTags() {
return registry -> registry.config()
.commonTags(
"application", "my-app",
"environment", "production",
"region", "us-east-1"
);
}
}
Boas Práticas de Tags
// ✅ BOM: Baixa cardinalidade
meterRegistry.counter("orders", "status", "COMPLETED"); // ~5 valores possíveis
meterRegistry.counter("orders", "type", "STANDARD"); // ~3 valores possíveis
// ❌ RUIM: Alta cardinalidade (explosão de séries)
meterRegistry.counter("orders", "orderId", order.getId()); // Milhões de valores!
meterRegistry.counter("users", "email", user.getEmail()); // Único por usuário!
6. Exportação para Prometheus
Configuração
# application.properties
management.endpoints.web.exposure.include=prometheus,health,metrics
management.prometheus.metrics.export.enabled=true
Formato 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. Resumo
Tipos de Métricas
| Tipo | Uso | Exemplo |
|---|---|---|
| Counter | Conta eventos | Requisições, erros |
| Gauge | Valor instantâneo | Memória, conexões ativas |
| Timer | Duração + contagem | Tempo de resposta |
| Summary | Distribuição | Percentis |
Criação de Métricas
// 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);
Anotações
@Timed("method.time")
@Counted("method.calls")
public void myMethod() { }
🎯 Próximo Passo
Métricas servem para medir. Mas como saber se a aplicação está saudável? Hora dos Health Checks!