Spring Boot 3.4 gebruiken om sporen uit aangepaste headers te verspreiden

Aangepaste headersporen verwerken in Spring Boot 3.4

Stel je voor dat je een Spring Boot 3.4-webservice hebt die naadloos met twee clients werkt. De eerste client gebruikt Spring Boot 3+, waardoor het doorgeven van sporen een fluitje van een cent wordt. Zonder enige extra inspanning krijgt u prachtige end-to-end trace-continuïteit 🪄. Logboeken zien er schoon en verbonden uit, als bij toverslag.

De zaken veranderen echter wanneer klant twee in het spel komt. In plaats van standaard traceringsheaders sturen ze aangepaste headers zoals `ot-custom-traceid` en `ot-custom-spanid`. Hoewel deze aangepaste headers geldige traceerinformatie bevatten, slaagt Spring Boot er niet in deze traceringen door te geven. Het resultaat? U verliest de mogelijkheid om clienttraceringen te verbinden met logboeken op de server.

Hierdoor ontstaat er een waarneembaarheidskloof. Voor klant één ziet u het volledige pad van een aanvraag tussen services. Voor client twee ziet u alleen logboeken aan de serverzijde, waarbij de kritieke clienttracering ontbreekt. Het is alsof je een halve puzzel ziet: je weet dat er iets ontbreekt, maar je kunt de stukjes niet in elkaar zetten. 😓

In dit artikel onderzoeken we hoe we dit probleem kunnen oplossen zonder te vertrouwen op Spring Cloud Sleuth, waarbij we trouw blijven aan het Spring Boot 3.4-ecosysteem. Aan het einde weet u hoe u traceringen van aangepaste headers kunt doorgeven en voortzetten, zodat u een naadloze observatie in uw hele systeem kunt garanderen.

Aangepaste headertracevoortplanting in Spring Boot

Een van de belangrijkste componenten bij het oplossen van dit probleem is CustomTraceFilter. Dit filter verlengt de OncePerRequestFilter class, waardoor de trace-headerlogica slechts één keer wordt uitgevoerd voor elk HTTP-verzoek. Filters in Spring Boot zijn ongelooflijk handig bij het wereldwijd wijzigen van verzoeken of antwoorden. Als de klant bijvoorbeeld traceringsinformatie verzendt zoals ot-aangepaste traceid of ot-aangepast-spanid in aangepaste headers onderschept dit filter het verzoek, extraheert deze headers en geeft deze door aan de Mapped Diagnostic Context (MDC). Door de trace-ID's aan de MDC toe te voegen, zorgen we ervoor dat deze ID's zichtbaar zijn in de logboeken die worden gegenereerd tijdens de verwerking van verzoeken.

De MDC is een cruciaal onderdeel van logboekregistratieframeworks zoals SLF4J en Logback. Hiermee kunnen we contextuele informatie voor de huidige thread opslaan, zoals aangepaste trace-ID's. Met behulp van commando's zoals MDC.put En MDC.helderzorgen we ervoor dat het logsysteem de traceerdetails bevat en besmetting tussen gelijktijdige verzoeken voorkomt. Als Klant Twee bijvoorbeeld 'ot-custom-traceid' verzendt als '8f7ebd8a73f9a8f50e6a00a87a20952a', wordt deze ID opgeslagen in MDC en opgenomen in alle downstream-logboeken, waardoor een consistent traceerpad ontstaat.

Aan de andere kant speelt de RestTemplate-interceptor voor uitgaande HTTP-verzoeken een essentiële rol. Door te implementeren ClientHttpRequestInterceptor, kunnen we dezelfde traceerheaders (`ot-custom-traceid` en `ot-custom-spanid`) aan uitgaande verzoeken koppelen. Dit zorgt ervoor dat de traceercontinuïteit behouden blijft wanneer de applicatie andere microservices aanroept. Wanneer de server bijvoorbeeld een verzoek met trace-ID `8f7ebd8a73f9a8f50e6a00a87a20952a` verwerkt, koppelt hij deze ID aan de uitgaande headers, zodat downstream-services de trace naadloos kunnen herkennen en doorgeven.

Ten slotte valideren de eenheidstests die zijn geschreven met MockMvc de gehele installatie door HTTP-verzoeken te simuleren en de headerpropagatie te verifiëren. In praktijktoepassingen is testen van cruciaal belang om ervoor te zorgen dat de traceerheaders correct worden afgehandeld. Door bijvoorbeeld een GET-verzoek met aangepaste headers te verzenden en de respons of logs te inspecteren, kunnen we bevestigen dat het filter en de interceptor werken zoals verwacht. Deze alomvattende aanpak lost de uitdaging op zonder te vertrouwen op verouderde afhankelijkheden zoals Spring Cloud Sleuth. Uiteindelijk zorgt de combinatie van filters, interceptors en MDC voor trace-continuïteit, zelfs wanneer clients aangepaste headers gebruiken, waardoor het systeem robuust en volledig waarneembaar wordt. 🌟

// 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;
    }
}

// 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());
    }
}

// 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;
    }
}

Aangepaste headertraceringen verwerken met OpenTelemetry in Spring Boot 3.4

Wanneer u met Spring Boot 3.4 werkt, is een andere krachtige aanpak om traceringen uit aangepaste headers te verspreiden het integreren OpenTelemetrie. OpenTelemetry, een open-source observatieframework, helpt bij het naadloos instrumenteren, verzamelen en exporteren van sporen. Het biedt mechanismen voor het extraheren en injecteren van traceercontext, inclusief aangepaste headers zoals ot-aangepaste traceid En ot-aangepast-spanid, in uw toepassing. Door gebruik te maken van TextMapPropagator van OpenTelemetry kunt u de kloof overbruggen tussen niet-standaard clients en uw observatiesysteem.

Om OpenTelemetry in Spring Boot 3.4 te gebruiken, kan een aangepaste propagator worden geïmplementeerd om traceringsinformatie uit de aangepaste headers te extraheren en deze aan de huidige traceringscontext te koppelen. Wanneer uw server bijvoorbeeld een inkomend verzoek ontvangt van Client Two, kan OpenTelemetry aangepaste headers parseren en de oorspronkelijke traceercontext reconstrueren. Dit zorgt ervoor dat downstream-services dezelfde trace-ID's zien, waardoor end-to-end zichtbaarheid mogelijk is. In tegenstelling tot oudere oplossingen zoals Spring Cloud Sleuth, is OpenTelemetry lichtgewicht en sluit het aan bij moderne observatiestandaarden.

Door de propagator van OpenTelemetry te combineren met Micrometer, kunt u uw statistieken en logboekregistratie verrijken met traceerinformatie. Stel u voor dat u in uw observatietool naadloos sporen ziet van verzoeken die afkomstig zijn van zowel Klant Eén als Klant Twee. OpenTelemetry ondersteunt automatisch integraties met Prometheus, Zipkin of Jaeger, waardoor u de traceringsvisualisatie kunt centraliseren. Deze aanpak zorgt ervoor dat zelfs als er sprake is van aangepaste headers, er geen traceergegevens verloren gaan en dat het opsporen van fouten aanzienlijk eenvoudiger wordt. 🚀