Observability w Spring Boot: metryki, trace i logi w praktyce

W nowoczesnych systemach backendowych samo „logowanie błędów” już nie wystarcza. Aplikacje są rozproszone, skalują się dynamicznie i komunikują się przez sieć. Dlatego coraz więcej zespołów wdraża observability – czyli zdolność systemu do odpowiadania na pytanie: co się właśnie dzieje i dlaczego?

Observability opiera się na trzech filarach:

• metrykach (metrics),
• śladach wywołań (traces),
• logach (logs).

Spring Boot (od wersji 3.x) ma wbudowane, produkcyjnie gotowe wsparcie dla wszystkich trzech obszarów.

1. Metryki – jak mierzyć zdrowie aplikacji

Metryki odpowiadają na pytania:

• ile jest requestów?
• jakie są czasy odpowiedzi?
• ile jest błędów?
• ile pamięci i CPU zużywa aplikacja?

W Spring Boot standardem jest Micrometer jako warstwa abstrakcji oraz integracja z:

• Prometheus,
• Grafana,
• Datadog,
• New Relic.

Konfiguracja (Prometheus)

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

management:
  endpoints:
    web:
      exposure:
        include: health,metrics,prometheus

Endpoint:

/actuator/prometheus

Własna metryka

@Component
public class OrderService {

    private final Counter orderCounter;

    public OrderService(MeterRegistry registry) {
        this.orderCounter = registry.counter("orders.created");
    }

    public void createOrder() {
        orderCounter.increment();
    }
}

Efekt: w Grafanie możesz obserwować liczbę zamówień w czasie rzeczywistym.

2. Distributed Tracing – śledzenie requestu przez cały system

Tracing pozwala zobaczyć, jak jedno żądanie przechodzi przez mikroserwisy, bazy danych i integracje.

Spring Boot 3 używa Micrometer Tracing z integracją z OpenTelemetry.

Typowe narzędzia:

• Jaeger,
• Zipkin,
• Tempo (Grafana).

Konfiguracja (OpenTelemetry)

<dependency>
  <groupId>io.micrometer</groupId>
  <artifactId>micrometer-tracing-bridge-otel</artifactId>
</dependency>

management:
  tracing:
    sampling:
      probability: 1.0

Przykład śladu (trace) w kodzie

@Autowired
Tracer tracer;

public void processOrder() {
    Span span = tracer.nextSpan().name("processOrder").start();
    try (Tracer.SpanInScope ws = tracer.withSpan(span)) {
        // logika biznesowa
    } finally {
        span.end();
    }
}

W Jaegerze zobaczysz:

• czas trwania metody,
• zależności między serwisami,
• wąskie gardła.

3. Logi – nadal kluczowe, ale inaczej używane

Logi odpowiadają na pytanie: co dokładnie się wydarzyło w tym konkretnym przypadku?

Dobra praktyka: logi strukturalne (JSON) zamiast zwykłego tekstu.

Przykład logowania z kontekstem trace

log.info("Processing order {}", orderId);

Po integracji z tracingiem log zawiera:

{
  "message": "Processing order 123",
  "traceId": "a8f1c92d",
  "spanId": "b7123f"
}

Dzięki temu można:

• kliknąć log,
• przejść do trace,
• zobaczyć cały przebieg requestu.

Jak to działa razem?

Przykład realnego scenariusza:

1. Alert: rośnie czas odpowiedzi API.
2. Sprawdzasz metryki – endpoint /orders ma 95th percentile = 2.5s.
3. Otwierasz trace – widzisz, że zapytanie do bazy trwa 2.2s.
4. W logach znajdujesz konkretne ID zapytania i błędne parametry.

To jest właśnie observability w praktyce, a nie tylko monitoring.

Typowe błędy we wdrażaniu observability

• logowanie wszystkiego (gigabajty danych bez wartości),
• brak korelacji logów z traceId,
• brak metryk biznesowych (np. liczba zamówień),
• brak alertów – tylko dashboardy,
• brak spójnych nazw metryk.

Minimalna checklista produkcyjna

• [ ] Actuator włączony
• [ ] Micrometer + Prometheus
• [ ] Tracing (OpenTelemetry)
• [ ] Logi z traceId/spanId
• [ ] Dashboardy (Grafana)
• [ ] Alerty (czas odpowiedzi, error rate)
• [ ] Metryki techniczne + biznesowe

Ciekawostki

• Netflix jako pierwszy spopularyzował termin „observability” w architekturach mikroserwisowych.
• Coraz więcej firm traktuje brak observability jako błąd architektoniczny.
• Dobrze wdrożone observability skraca czas debugowania z godzin do minut.

Oficjalne źródła i dokumentacja

• Spring Boot Actuator
• Micrometer
• Micrometer Tracing
• OpenTelemetry
• Prometheus
• Grafana

Podsumowanie

Observability w Spring Boot to dziś standard produkcyjny, a nie luksus:

• metryki pokazują kondycję systemu,
• trace tłumaczą, gdzie ginie czas,
• logi wyjaśniają, co dokładnie się wydarzyło.

Dzięki wbudowanym narzędziom Spring Boot 3, Micrometerowi i OpenTelemetry można wdrożyć pełne observability bez budowania własnych rozwiązań od zera.

W świecie mikroserwisów i chmury: system, którego nie da się obserwować, jest systemem, którego nie da się utrzymać.