Implement Simple Request Tracing in SpringBoot 3.2 with SLF4J and MDC

Environment: SpringBoot 3.2.0

1. Introduction

Combining SpringBoot with SLF4J enables easy implementation of request tracing, improving maintainability and diagnosability. Tracing records the request chain via logs, allowing developers to quickly locate and resolve issues.

Instead of using external systems like Zipkin or SkyWalking, we build a simple tracing mechanism that stores a unique trace ID in MDC (Mapped Diagnostic Context) using ThreadLocal, ensuring thread safety.

Benefits of tracing

Improved maintainability and diagnosability : Understand service interactions and latency.

Optimized performance : Analyze dependencies and resource usage.

Enhanced security and reliability : Monitor runtime status and exceptions.

Assisted design and development : Reveal architecture and flow for better scalability.

2. Hands‑on implementation

We create a custom filter that generates or extracts a traceId from the request header and stores it in MDC.

<code>@WebFilter("/**")
@Component
public class TraceXFilter implements Filter {
    private static final Logger logger = LoggerFactory.getLogger(TraceXFilter.class);
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        String traceId = req.getHeader("x-trace");
        if (!StringUtils.hasLength(traceId)) {
            traceId = UUID.randomUUID().toString().replace("-", "").toUpperCase();
        }
        MDC.put(TRACE_KEY, traceId);
        logger.info("请求: {}", req.getServletPath());
        chain.doFilter(request, response);
    }
}
</code>

Configure logback‑spring.xml to output the trace ID:

<code>&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;configuration scan="true"&gt;
    &lt;property name="DEFAULT_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger Line:%-3L - %msg%n"/&gt;
    &lt;property name="TRACEX_PATTERN" value="%green(%d{yyyy-MM-dd HH:mm:ss.SSS}) %highlight(%-5level) [%yellow(%thread)] %logger Line:%-3L traceId:【%red(%X{traceXId})】 - %msg%n"/&gt;
    &lt;appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender"&gt;
        &lt;encoder&gt;
            &lt;pattern&gt;${DEFAULT_PATTERN}&lt;/pattern&gt;
            &lt;charset&gt;UTF-8&lt;/charset&gt;
        &lt;/encoder&gt;
    &lt;/appender&gt;
    &lt;appender name="TRACEX" class="ch.qos.logback.core.ConsoleAppender"&gt;
        &lt;encoder&gt;
            &lt;pattern&gt;${TRACEX_PATTERN}&lt;/pattern&gt;
            &lt;charset&gt;UTF-8&lt;/charset&gt;
        &lt;/encoder&gt;
    &lt;/appender&gt;
    &lt;logger name="com.pack.tracex.test" additivity="false" level="INFO"&gt;
        &lt;appender-ref ref="TRACEX"/&gt;
    &lt;/logger&gt;
    &lt;springProfile name="dev"&gt;
        &lt;root level="INFO"&gt;
            &lt;appender-ref ref="CONSOLE"/&gt;
        &lt;/root&gt;
    &lt;/springProfile&gt;
&lt;/configuration&gt;
</code>

Define a simple controller to test the tracing:

<code>private static final Logger logger = LoggerFactory.getLogger(TraceController.class);
@Resource
private HttpServletRequest request;
@Resource
private UsersService usersService;

@GetMapping("")
public List&lt;Users&gt; index() throws Exception {
    logger.info("start uri: {}", "/tracex");
    List&lt;Users&gt; list = this.usersService.list();
    logger.info("end uri: {}", "/tracex");
    return list;
}
</code>

Running the endpoint produces log entries that include the same traceId for the request, the controller, and the SQL statements, enabling end‑to‑end correlation.

Two further improvements are suggested:

Log SQL bind parameters by adding a TRACE‑level logger for org.hibernate.orm.jdbc.bind .

Return the traceId to the client using a ResponseBodyAdvice implementation.

Adding the following logger configuration prints SQL parameters:

<code>&lt;logger name="org.hibernate.orm.jdbc.bind" level="TRACE"&gt;
    &lt;appender-ref ref="TRACEX"/&gt;
&lt;/logger&gt;
</code>

Implementing a global ResponseBodyAdvice injects the trace ID into every response:

<code>@RestControllerAdvice
public class PackResponseBodyAdvice implements ResponseBodyAdvice&lt;Object&gt; {
    @Resource
    private ObjectMapper objectMapper;
    @Override
    public boolean supports(MethodParameter returnType, Class&lt;? extends HttpMessageConverter&lt;?&gt;&gt; converterType) {
        return !returnType.getParameterType().equals(R.class);
    }
    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType,
                                 Class&lt;? extends HttpMessageConverter&lt;?&gt;&gt; selectedConverterType,
                                 ServerHttpRequest request, ServerHttpResponse response) {
        if (body instanceof String) {
            try {
                return objectMapper.writeValueAsString(R.success(response, MDC.get(TraceX.TRACE_KEY)));
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        }
        if (body instanceof ResponseEntity<?> entity) {
            return R.success(entity.getBody(), MDC.get(TraceX.TRACE_KEY));
        }
        return R.success(body, MDC.get(TraceX.TRACE_KEY));
    }
}
</code>

After this change, the API response contains the traceId , allowing developers to match client‑side errors with server logs.

Example response (image):

The article concludes that the simple tracing setup, together with the two optimizations, provides a practical way to improve debugging and observability in SpringBoot applications.