So verwenden Sie Spring Boot 3.4 zur Weitergabe von Ablaufverfolgungen aus benutzerdefinierten Headern

Umgang mit benutzerdefinierten Header-Traces in Spring Boot 3.4

Stellen Sie sich vor, Sie verfügen über einen Spring Boot 3.4-Webdienst, der nahtlos mit zwei Clients zusammenarbeitet. Der erste Client verwendet Spring Boot 3+, wodurch die Trace-Weitergabe zum Kinderspiel wird. Ohne zusätzlichen Aufwand erhalten Sie eine wunderschöne End-to-End-Trace-Kontinuität 🪄. Protokolle erscheinen sauber und verbunden, wie von Zauberhand.

Doch als Kunde zwei ins Spiel kommt, nehmen die Dinge eine Wendung. Anstelle von Standard-Tracing-Headern senden sie benutzerdefinierte Header wie „ot-custom-traceid“ und „ot-custom-spanid“. Obwohl diese benutzerdefinierten Header gültige Trace-Informationen enthalten, kann Spring Boot diese Traces nicht weitergeben. Das Ergebnis? Sie verlieren die Möglichkeit, Client-Ablaufverfolgungen mit serverseitigen Protokollen zu verbinden.

Dadurch entsteht eine Beobachtbarkeitslücke. Für Client eins sehen Sie den vollständigen Pfad einer Anfrage über alle Dienste hinweg. Für Client zwei werden nur serverseitige Protokolle angezeigt, der kritische Client-Trace fehlt. Es ist, als würde man ein halbes Puzzle sehen – man weiß, dass etwas fehlt, kann aber die Teile nicht zusammenfügen. 😓

In diesem Artikel untersuchen wir, wie Sie dieses Problem lösen können, ohne sich auf Spring Cloud Sleuth zu verlassen und dabei dem Spring Boot 3.4-Ökosystem treu zu bleiben. Am Ende wissen Sie, wie Sie Traces von benutzerdefinierten Headern weitergeben und fortsetzen, um eine nahtlose Beobachtbarkeit in Ihrem gesamten System sicherzustellen.

Benutzerdefinierte Header-Trace-Weitergabe in Spring Boot

Eine der Schlüsselkomponenten zur Lösung dieses Problems ist der CustomTraceFilter. Dieser Filter erweitert die OncePerRequestFilter Klasse, wodurch sichergestellt wird, dass die Trace-Header-Logik für jede HTTP-Anfrage nur einmal ausgeführt wird. Filter in Spring Boot sind unglaublich nützlich, wenn es darum geht, Anfragen oder Antworten global zu ändern. Wenn der Client beispielsweise Tracing-Informationen sendet, z. B ot-custom-traceid oder ot-custom-spanid In benutzerdefinierten Headern fängt dieser Filter die Anfrage ab, extrahiert diese Header und gibt sie an den Mapped Diagnostic Context (MDC) weiter. Durch das Hinzufügen der Trace-IDs zum MDC stellen wir sicher, dass diese Kennungen in den Protokollen sichtbar sind, die während der Anforderungsverarbeitung generiert werden.

Der MDC ist ein wichtiger Bestandteil von Protokollierungsframeworks wie SLF4J und Logback. Es ermöglicht uns, Kontextinformationen für den aktuellen Thread zu speichern, beispielsweise benutzerdefinierte Trace-IDs. Mit Befehlen wie MDC.put Und MDC.klarstellen wir sicher, dass das Protokollierungssystem die Trace-Details enthält und eine Kontamination zwischen gleichzeitigen Anfragen verhindert. Wenn Client Zwei beispielsweise „ot-custom-traceid“ als „8f7ebd8a73f9a8f50e6a00a87a20952a“ sendet, wird diese ID im MDC gespeichert und in alle Downstream-Protokolle aufgenommen, wodurch ein konsistenter Trace-Pfad entsteht.

Für ausgehende HTTP-Anfragen hingegen spielt der RestTemplate-Interceptor eine wesentliche Rolle. Durch die Umsetzung ClientHttpRequestInterceptorkönnen wir ausgehenden Anfragen dieselben Trace-Header („ot-custom-traceid“ und „ot-custom-spanid“) anhängen. Dadurch wird sichergestellt, dass die Trace-Kontinuität gewahrt bleibt, wenn die Anwendung andere Microservices aufruft. Wenn der Server beispielsweise eine Anfrage mit der Trace-ID „8f7ebd8a73f9a8f50e6a00a87a20952a“ verarbeitet, hängt er diese ID an die ausgehenden Header an, sodass nachgelagerte Dienste den Trace nahtlos erkennen und weitergeben können.

Schließlich validieren die mit MockMvc geschriebenen Komponententests das gesamte Setup, indem sie HTTP-Anfragen simulieren und die Header-Weitergabe überprüfen. In realen Anwendungen ist das Testen von entscheidender Bedeutung, um sicherzustellen, dass die Trace-Header korrekt verarbeitet werden. Indem wir beispielsweise eine GET-Anfrage mit benutzerdefinierten Headern senden und die Antwort oder Protokolle überprüfen, können wir bestätigen, dass der Filter und der Interceptor wie erwartet funktionieren. Dieser umfassende Ansatz löst die Herausforderung, ohne auf Legacy-Abhängigkeiten wie Spring Cloud Sleuth angewiesen zu sein. Letztendlich gewährleistet die Kombination aus Filtern, Interceptoren und MDC die Trace-Kontinuität, selbst wenn Clients benutzerdefinierte Header verwenden, wodurch das System robust und vollständig beobachtbar wird. 🌟

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

Umgang mit benutzerdefinierten Header-Traces mit OpenTelemetry in Spring Boot 3.4

Bei der Arbeit mit Spring Boot 3.4 ist die Integration ein weiterer leistungsstarker Ansatz zur Weitergabe von Ablaufverfolgungen aus benutzerdefinierten Headern OpenTelemetry. OpenTelemetry, ein Open-Source-Observability-Framework, hilft dabei, Spuren nahtlos zu instrumentieren, zu sammeln und zu exportieren. Es bietet Mechanismen zum Extrahieren und Einfügen von Trace-Kontext, einschließlich benutzerdefinierter Header wie ot-custom-traceid Und ot-custom-spanid, in Ihre Bewerbung. Durch die Nutzung des TextMapPropagator von OpenTelemetry können Sie die Lücke zwischen nicht standardmäßigen Clients und Ihrem Observability-System schließen.

Um OpenTelemetry in Spring Boot 3.4 zu verwenden, kann ein benutzerdefinierter Propagator implementiert werden, um Tracing-Informationen aus den benutzerdefinierten Headern zu extrahieren und sie an den aktuellen Trace-Kontext anzuhängen. Wenn Ihr Server beispielsweise eine eingehende Anfrage von Client Zwei empfängt, kann OpenTelemetry benutzerdefinierte Header analysieren und den ursprünglichen Trace-Kontext rekonstruieren. Dadurch wird sichergestellt, dass nachgelagerte Dienste dieselben Trace-IDs sehen, was eine durchgängige Sichtbarkeit ermöglicht. Im Gegensatz zu älteren Lösungen wie Spring Cloud Sleuth ist OpenTelemetry leichtgewichtig und entspricht modernen Observability-Standards.

Durch die Kombination des Propagators von OpenTelemetry mit Micrometer können Sie Ihre Metriken und Protokolle mit Trace-Informationen anreichern. Stellen Sie sich vor, Sie sehen in Ihrem Observability-Tool nahtlos Ablaufverfolgungen für Anfragen, die sowohl von Client Eins als auch von Client Zwei kommen. OpenTelemetry unterstützt automatisch Integrationen mit Prometheus, Zipkin oder Jaeger und ermöglicht Ihnen so die Zentralisierung der Trace-Visualisierung. Dieser Ansatz stellt sicher, dass auch bei benutzerdefinierten Headern keine Trace-Daten verloren gehen und das Debuggen erheblich einfacher wird. 🚀