How to Use Spring Boot 3.4 to Propagate Traces from Custom Headers

Propagating Custom Tracing Headers in Spring Boot 3.4

Using Java with Spring Boot 3.4 and Micrometer for Backend Processing

// Solution 1: Extract and Propagate Custom Trace Headers Manually
// Import necessary Spring Boot and Micrometer libraries
import org.slf4j.MDC;
import org.springframework.http.HttpHeaders;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class CustomTraceFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws IOException {
        String traceId = request.getHeader("ot-custom-traceid");
        String spanId = request.getHeader("ot-custom-spanid");
        try {
            if (traceId != null) {
                MDC.put("traceId", traceId); // Add traceId to Mapped Diagnostic Context
            }
            if (spanId != null) {
                MDC.put("spanId", spanId);
            }
            filterChain.doFilter(request, response); // Continue request processing
        } finally {
            MDC.clear(); // Ensure MDC is cleared after processing
        }
    }
}

// Register the filter in your configuration class
@Configuration
public class FilterConfig {
    @Bean
    public FilterRegistrationBean<CustomTraceFilter> traceFilter() {
        FilterRegistrationBean<CustomTraceFilter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new CustomTraceFilter());
        registrationBean.addUrlPatterns("/*");
        return registrationBean;
    }
}

Unit Test for Custom Trace Header Propagation

Testing with JUnit and MockMvc to Validate Trace Header Propagation

// Import necessary libraries
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.test.web.servlet.MockMvc;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@WebMvcTest
public class CustomTraceFilterTest {
    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testCustomTraceHeaders() throws Exception {
        mockMvc.perform(get("/test-endpoint")
                .header("ot-custom-traceid", "12345")
                .header("ot-custom-spanid", "67890"))
                .andExpect(status().isOk());
    }
}

Propagating Custom Headers in HTTP Requests Using RestTemplate

Using RestTemplate Interceptors to Add Custom Headers in Outgoing Requests

// Import necessary libraries
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.web.client.RestTemplate;
import java.io.IOException;

public class CustomHeaderInterceptor implements ClientHttpRequestInterceptor {
    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        HttpHeaders headers = request.getHeaders();
        headers.add("ot-custom-traceid", "12345");
        headers.add("ot-custom-spanid", "67890");
        return execution.execute(request, body);
    }
}

// Register the interceptor with RestTemplate
@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.getInterceptors().add(new CustomHeaderInterceptor());
        return restTemplate;
    }
}

Frequently Asked Questions about Propagating Custom Traces in Spring Boot

1. How do I manually extract custom trace headers in Spring Boot?
2. You can use request.getHeader("custom-header") to manually fetch a specific header and add it to the MDC using MDC.put("traceId", value).
3. What is the benefit of using OpenTelemetry for custom trace propagation?
4. OpenTelemetry provides a modern, vendor-neutral approach to propagating traces, including custom headers, across microservices.
5. Can I propagate custom headers with RestTemplate in Spring Boot?
6. Yes, by implementing a ClientHttpRequestInterceptor, you can attach custom headers like traceid and spanid to outgoing requests.
7. How do I register a filter to capture headers globally?
8. You can create a filter that extends OncePerRequestFilter and register it using FilterRegistrationBean to capture headers for all endpoints.
9. What tools can I use to visualize traces from Spring Boot?
10. Tools like Zipkin, Jaeger, and Prometheus can integrate with Spring Boot and OpenTelemetry to visualize end-to-end traces.

Ensuring Seamless Trace Continuity

In modern systems, handling custom trace headers is critical for reliable observability. By using filters and interceptors, you can capture client-provided tracing information and propagate it correctly across your services. This avoids fragmented logs and missing traces. 🔍

Spring Boot 3.4, combined with Micrometer or OpenTelemetry, allows robust solutions without relying on older tools like Spring Cloud Sleuth. Whether you're dealing with Client One’s standard headers or Client Two’s custom headers, implementing these techniques bridges the trace gaps efficiently. 🚀