package com.example.observability;
public final class CorrelationIdConstants {
public static final String HEADER_NAME = "X-Correlation-Id";
public static final String MDC_KEY = "correlationId";
private CorrelationIdConstants() {
}
}
package com.example.observability;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.slf4j.MDC;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;
import java.io.IOException;
import java.util.UUID;
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class CorrelationIdFilter extends OncePerRequestFilter {
@Override
protected void doFilterInternal(HttpServletRequest request,
HttpServletResponse response,
FilterChain chain) throws ServletException, IOException {
String correlationId = resolveCorrelationId(request);
MDC.put(CorrelationIdConstants.MDC_KEY, correlationId);
response.setHeader(CorrelationIdConstants.HEADER_NAME, correlationId);
try {
chain.doFilter(request, response);
} finally {
MDC.remove(CorrelationIdConstants.MDC_KEY);
}
}
private String resolveCorrelationId(HttpServletRequest request) {
String incoming = request.getHeader(CorrelationIdConstants.HEADER_NAME);
if (StringUtils.hasText(incoming)) {
return incoming.trim();
}
return UUID.randomUUID().toString();
}
}
package com.example.observability;
import org.slf4j.MDC;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.ClientRequest;
import org.springframework.web.reactive.function.client.ExchangeFilterFunction;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;
@Configuration
public class TracingWebClientConfig {
@Bean
public WebClient tracingWebClient(WebClient.Builder builder) {
return builder.filter(propagateCorrelationId()).build();
}
private ExchangeFilterFunction propagateCorrelationId() {
return (request, next) -> {
String correlationId = MDC.get(CorrelationIdConstants.MDC_KEY);
if (correlationId == null) {
return next.exchange(request);
}
ClientRequest traced = ClientRequest.from(request)
.header(CorrelationIdConstants.HEADER_NAME, correlationId)
.build();
return next.exchange(traced);
};
}
}
<configuration>
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{HH:mm:ss.SSS} %-5level [%X{correlationId:-no-correlation-id}] %logger{36} - %msg%n</pattern>
</encoder>
</appender>
<root level="INFO">
<appender-ref ref="CONSOLE"/>
</root>
</configuration>
This snippet shows how a single request-scoped identifier can be attached to every log line produced while handling an HTTP request, so that logs from many concurrent requests can be untangled after the fact. The technique relies on SLF4J's MDC (Mapped Diagnostic Context), a thread-local map whose entries the logging framework can interpolate into each line via a pattern token.
In CorrelationIdFilter, an OncePerRequestFilter runs at the very start of the servlet chain. It reads an incoming X-Correlation-Id header if the caller already supplied one (useful when an upstream service or gateway started the trace), and otherwise mints a fresh UUID. The value is placed into MDC under the key correlationId and echoed back on the response so clients can capture it. The try/finally is the critical detail: because MDC is backed by a thread-local, failing to call MDC.remove would leak the id onto the next request that reuses the same pooled worker thread, producing subtly wrong logs. Ordering the filter with @Order(HIGHEST_PRECEDENCE) ensures the context is set before any downstream filter, controller, or exception handler logs anything.
The CorrelationIdConstants tab centralises the header name and MDC key so the filter, the client wrapper, and tests never drift apart on string literals. CorrelationContext exposes a tiny read accessor so application code can retrieve the current id without depending on SLF4J directly.
To keep the trace intact across service boundaries, TracingWebClientConfig registers an ExchangeFilterFunction on a WebClient. Before each outbound call it reads the current id from MDC and copies it into the outbound request's headers, so the downstream service's own filter can pick it up and continue the same trace.
The logback-spring.xml tab wires everything together by adding [%X{correlationId}] to the console pattern; %X{...} is Logback's syntax for pulling a named value out of the MDC. A key pitfall this pattern does not solve on its own is asynchronous work: when a request hands off to a @Async method or a manually managed thread pool, the MDC does not propagate automatically and must be copied explicitly or wrapped with a task decorator. For plain synchronous request handling, however, this filter-based approach adds structured, greppable context to every log line at almost zero cost.
Related snips
package api
import (
"net/http"
"runtime/debug"
)Expose build metadata for debugging deploys
type User {
id: ID!
name: String!
email: String!
posts: [Post!]!
createdAt: String!GraphQL API with Spring Boot
use tracing::{info, instrument};
#[instrument]
fn process_request(user_id: u64) {
info!(user_id, "Processing request");
// Work happens heretracing for structured logging and distributed tracing
package com.example.starter.config;
import com.example.starter.properties.CustomProperties;
import com.example.starter.service.CustomService;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;Custom Spring Boot starters
# Grafana provisioning: datasources
# /etc/grafana/provisioning/datasources/prometheus.yml
apiVersion: 1
datasources:
- name: Prometheus
type: prometheusGrafana dashboards as code with JSON provisioning
import React from "react";
type FallbackProps = {
error: Error;
reset: () => void;
};React Error Boundary + error reporting hook
Share this code
Here's the card — post it anywhere.
