Correlate Logs, Metrics & Traces

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

package com.example.order;

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

import java.time.Duration;

@Component
public class OrderMetrics {

    private final Counter orderSuccessCounter;
    private final Counter orderFailureCounter;
    private final Timer orderProcessingTimer;

    public OrderMetrics(MeterRegistry registry) {
        this.orderSuccessCounter = Counter.builder("app.orders.completed")
            .description("Total number of successfully placed orders")
            .tag("status", "success")
            .register(registry);

        this.orderFailureCounter = Counter.builder("app.orders.completed")
            .description("Total number of failed orders")
            .tag("status", "failure")
            .register(registry);

        this.orderProcessingTimer = Timer.builder("app.orders.processing.time")
            .description("Latency of the complete order processing pipeline")
            .publishPercentileHistogram() // Enables Prometheus histogram_quantile calculations!
            .sla(Duration.ofMillis(200), Duration.ofMillis(500), Duration.ofSeconds(1))
            .register(registry);
    }

    public void recordSuccess(Duration duration) {
        orderSuccessCounter.increment();
        orderProcessingTimer.record(duration);
    }

    public void recordFailure() {
        orderFailureCounter.increment();
    }
}

1
2
3
4
5
6
7
8
9
10

<!-- Micrometer Tracing Bridge with OpenTelemetry -->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-tracing-bridge-otel</artifactId>
</dependency>
<!-- Export traces to OpenTelemetry Collector / Tempo / Jaeger -->
<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-exporter-otlp</artifactId>
</dependency>

1
2
3
4
5
6
7
8

management:
  tracing:
    sampling:
      probability: 1.0 # Sample 100% in dev/staging; use 0.05 (5%) or 0.1 (10%) in high-traffic prod
    enabled: true
  otlp:
    tracing:
      endpoint: "http://otel-collector:4318/v1/traces"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

package com.example.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(25);
        executor.setQueueCapacity(500);
        executor.setThreadNamePrefix("async-worker-");
        // CRITICAL: Propagate MDC and Tracing Context across thread boundaries:
        executor.setTaskDecorator(runnable -> {
            var contextMap = org.slf4j.MDC.getCopyOfContextMap();
            return () -> {
                try {
                    if (contextMap != null) {
                        org.slf4j.MDC.setContextMap(contextMap);
                    }
                    runnable.run();
                } finally {
                    org.slf4j.MDC.clear();
                }
            };
        });
        executor.initialize();
        return executor;
    }
}