A Spring Boot 3.4 használata nyomok terjesztésére egyéni fejlécekből

Egyéni fejlécnyomok kezelése Spring Boot 3.4-ben

Képzelje el, hogy van egy Spring Boot 3.4 webszolgáltatása, amely zökkenőmentesen működik két klienssel. Az első kliens a Spring Boot 3+-ot használja, így a nyomkövetési terjesztés gyerekjáték. Minden extra erőfeszítés nélkül gyönyörű végtől végpontig terjedő nyomkövetési folytonosságot 🪄. A naplók tisztának és összefüggőnek tűnnek, mintha varázsütésre.

A dolgok azonban fordulatot vesznek, amikor a kliens kettes szóba kerül. A szabványos nyomkövetési fejlécek helyett olyan egyéni fejléceket küldenek, mint az "ot-custom-traceid" és az "ot-custom-spanid". Bár ezek az egyéni fejlécek érvényes nyomkövetési információkat tartalmaznak, a Spring Boot nem tudja továbbítani ezeket a nyomkövetéseket. Az eredmény? Elveszíti azt a képességét, hogy az ügyfélnyomkövetéseket kiszolgálóoldali naplókkal összekapcsolja.

Ez megfigyelhetőségi rést hoz létre. Az egyik ügyfél esetében láthatja a kérés teljes útvonalát a szolgáltatások között. A második ügyfél esetében csak a szerveroldali naplókat látja, hiányzik a kritikus ügyfélkövetés. Olyan, mintha egy fél puzzle-t látnál – tudod, hogy valami hiányzik, de nem tudod összerakni a darabokat. 😓

Ebben a cikkben azt fogjuk megvizsgálni, hogyan lehet megoldani ezt a problémát a Spring Cloud Sleuth-re támaszkodás nélkül, hűek maradva a Spring Boot 3.4 ökoszisztémához. A végére tudni fogja, hogyan terjesztheti és folytathatja az egyéni fejlécekből származó nyomkövetéseket, biztosítva a zökkenőmentes megfigyelhetőséget az egész rendszeren.

Egyéni fejléc nyomkövetési terjesztése Spring Bootban

A probléma megoldásának egyik kulcsfontosságú összetevője a CustomTraceFilter. Ez a szűrő kiterjeszti a OncePerRequestFilter osztályban, biztosítva, hogy a nyomkövetési fejléc logikája csak egyszer futhasson minden HTTP-kéréshez. A Spring Boot szűrői hihetetlenül hasznosak a kérések vagy válaszok globális módosítása során. Például, ha az ügyfél nyomkövetési információkat küld, mint pl ot-custom-traceid vagy ot-custom-spanid az egyéni fejlécekben ez a szűrő elfogja a kérést, kibontja ezeket a fejléceket, és továbbítja a Mapped Diagnostic Context (MDC)-be. A nyomkövetési azonosítók hozzáadásával az MDC-hez biztosítjuk, hogy ezek az azonosítók láthatóak legyenek a kérésfeldolgozás során generált naplókban.

Az MDC a naplózási keretrendszerek, például az SLF4J és a Logback kritikus része. Lehetővé teszi az aktuális szál környezeti információinak, például egyéni nyomkövetési azonosítók tárolását. Olyan parancsok használata, mint pl MDC.put és MDC.tiszta, biztosítjuk, hogy a naplózási rendszer tartalmazza a nyomkövetési adatokat, és elkerülje az egyidejű kérések közötti szennyeződést. Például, ha a kettes ügyfél az "ot-custom-traceid" értéket "8f7ebd8a73f9a8f50e6a00a87a20952a" néven küldi el, akkor ezt az azonosítót a rendszer az MDC-ben tárolja, és az összes későbbi naplóban szerepel, következetes nyomkövetési útvonalat hozva létre.

Másrészt a kimenő HTTP-kéréseknél a RestTemplate elfogó alapvető szerepet játszik. Megvalósításával ClientHttpRequestInterceptor, ugyanazokat a nyomkövetési fejléceket (`ot-custom-traceid` és `ot-custom-spanid`) csatolhatjuk a kimenő kérésekhez. Ez biztosítja, hogy a nyomkövetési folytonosság megmaradjon, amikor az alkalmazás más mikroszolgáltatásokat hív meg. Például amikor a kiszolgáló feldolgozza a `8f7ebd8a73f9a8f50e6a00a87a20952a` nyomkövetési azonosítójú kérelmet, ezt az azonosítót csatolja a kimenő fejlécekhez, így a továbbmenő szolgáltatások zökkenőmentesen felismerhetik és terjeszthetik a nyomkövetést.

Végül a MockMvc-el írt egységtesztek a HTTP kérések szimulálásával és a fejléc terjedésének ellenőrzésével érvényesítik a teljes beállítást. A valós alkalmazásokban a tesztelés kulcsfontosságú a nyomkövetési fejlécek megfelelő kezelésének biztosításához. Például egy egyedi fejlécekkel ellátott GET kérés elküldésével és a válasz vagy a naplók ellenőrzésével megerősíthetjük, hogy a szűrő és az elfogó a várt módon működik. Ez az átfogó megközelítés megoldja a kihívást anélkül, hogy olyan örökölt függőségekre hagyatkozna, mint a Spring Cloud Sleuth. Végül a szűrők, elfogók és MDC kombinációja biztosítja a nyomkövetési folytonosságot még akkor is, ha az ügyfelek egyéni fejléceket használnak, így a rendszer robusztussá és teljes mértékben megfigyelhetővé válik. 🌟

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

Egyéni fejléc nyomkövetések kezelése OpenTelemetry segítségével a Spring Boot 3.4-ben

Amikor a Spring Boot 3.4 verzióval dolgozik, egy másik hatékony módszer az egyéni fejlécek nyomainak terjesztésére az integráció OpenTelemetry. Az OpenTelemetry, egy nyílt forráskódú megfigyelési keretrendszer, segít a nyomkövetések zökkenőmentesen műszerezni, összegyűjteni és exportálni. Mechanizmusokat biztosít a nyomkövetési kontextus kinyerésére és beillesztésére, beleértve az egyéni fejléceket is ot-custom-traceid és ot-custom-spanid, az alkalmazásába. Az OpenTelemetry TextMapPropagator-jának kihasználásával áthidalhatja a szakadékot a nem szabványos kliensek és a megfigyelési rendszere között.

Az OpenTelemetry használatához a Spring Boot 3.4-ben egy egyéni propagátor valósítható meg, amely nyomkövetési információkat nyer ki az egyéni fejlécekből, és csatolja azokat az aktuális nyomkövetési kontextushoz. Például, ha a szervere bejövő kérést kap a második ügyféltől, az OpenTelemetry képes elemezni az egyéni fejléceket, és rekonstruálni az eredeti nyomkövetési kontextust. Ez biztosítja, hogy a downstream szolgáltatások ugyanazokat a nyomkövetési azonosítókat lássák, lehetővé téve a végpontok közötti láthatóságot. A régebbi megoldásoktól, például a Spring Cloud Sleuth-tól eltérően az OpenTelemetry könnyű, és megfelel a modern megfigyelési szabványoknak.

Az OpenTelemetry propagátorának a Mikrométerrel kombinálásával nyomon követési információkkal gazdagíthatja metrikáit és naplózását. Képzelje el, hogy a megfigyelési eszközben zökkenőmentesen látja az első és második ügyféltől érkező kérések nyomait. Az OpenTelemetry automatikusan támogatja a Prometheus, Zipkin vagy Jaeger integrációját, lehetővé téve a nyomkövetési megjelenítés központosítását. Ez a megközelítés biztosítja, hogy még egyéni fejlécek esetén se vesszenek el nyomkövetési adatok, és a hibakeresés jelentősen könnyebbé válik. 🚀