package com.example.tracing;
import jakarta.servlet.Filter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
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 java.io.IOException;
import java.util.UUID;
import java.util.regex.Pattern;
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class CorrelationIdFilter implements Filter {
public static final String HEADER = "X-Correlation-Id";
public static final String MDC_KEY = "correlationId";
private static final Pattern VALID = Pattern.compile("[A-Za-z0-9\\-]{8,64}");
@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
String correlationId = resolve(request.getHeader(HEADER));
MDC.put(MDC_KEY, correlationId);
response.setHeader(HEADER, correlationId);
try {
chain.doFilter(request, response);
} finally {
MDC.remove(MDC_KEY);
}
}
private String resolve(String incoming) {
if (incoming != null && VALID.matcher(incoming).matches()) {
return incoming;
}
return newId();
}
private String newId() {
return UUID.randomUUID().toString();
}
}
<configuration>
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level [%X{correlationId:-no-correlation-id}] %logger{36} - %msg%n</pattern>
</encoder>
</appender>
<root level="INFO">
<appender-ref ref="CONSOLE"/>
</root>
<logger name="com.example" level="DEBUG"/>
</configuration>
package com.example.tracing;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.slf4j.MDC;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class FeignCorrelationInterceptor {
@Bean
public RequestInterceptor correlationIdRequestInterceptor() {
return new RequestInterceptor() {
@Override
public void apply(RequestTemplate template) {
String correlationId = MDC.get(CorrelationIdFilter.MDC_KEY);
if (correlationId != null && !template.headers().containsKey(CorrelationIdFilter.HEADER)) {
template.header(CorrelationIdFilter.HEADER, correlationId);
}
}
};
}
}
This snippet shows how a correlation ID flows through a request-handling stack so that every log line for a single request can be tied together, even across thread boundaries and outbound HTTP calls. The core idea is to extract or generate an identifier once at the edge of the system and store it in SLF4J's Mapped Diagnostic Context (MDC), which is a per-thread key/value map that the logging pattern can reference automatically.
In CorrelationIdFilter, the servlet filter reads an incoming X-Correlation-Id header. If the caller supplies one, it is validated with a conservative regex to avoid log-forging or unbounded values; otherwise a fresh UUID is generated with newId(). The value is placed into MDC under a stable key and also written back onto the response so clients and gateways can observe it. The crucial detail is the try/finally block: MDC.remove(MDC_KEY) must run no matter what, because servlet containers pool and reuse threads, and a stale value would leak into an unrelated later request. Registering the filter with @Order(HIGHEST_PRECEDENCE) ensures the ID is set before any downstream logging occurs.
logback-spring.xml wires the value into output. The pattern references %X{correlationId} and defaultValue renders a placeholder when no ID is present (for example, on startup logs that run outside any request). Because the appender reads MDC at format time, no logging call site needs to know about correlation IDs at all — instrumentation stays out of business code.
FeignCorrelationInterceptor closes the loop for outbound calls. When a service calls another service via Feign, the interceptor copies the current MDC value into the X-Correlation-Id header of the outgoing request, so the downstream service's own CorrelationIdFilter will pick it up and continue the same trace.
The main trade-off with MDC is its thread affinity: work handed to a different thread (an @Async method, a thread pool, a reactive scheduler) does not inherit the context automatically, so a TaskDecorator or manual copy is needed there. Used at the servlet edge, though, this pattern is cheap, dependency-light, and dramatically improves log correlation.
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.
