Application Real-Time Monitoring Service:Conectar traces de frontend e backend

Application Monitoring agent

O agente do ARMS Application Monitoring possui suporte nativo ao protocolo OpenTelemetry. Portanto, é possível correlacionar traces com o RUM sem configurações adicionais. No entanto, certifique-se dos seguintes pontos:

• O agente do Application Monitoring deve ser da versão 2.x, 3.x ou 4.x. Recomendamos atualizar para a versão 4.x para garantir a melhor experiência.

• Use um container web mainstream, como Tomcat, Jetty, WebLogic ou Undertow, além de um framework suportado, como SpringBoot ou SpringMVC. Para obter a lista completa de componentes e frameworks suportados, consulte Java components and frameworks supported by Application Monitoring.

Para instruções sobre como instalar o agente do Application Monitoring, consulte Monitor Java applications.

OpenTelemetry

Instrumente seu aplicativo com OpenTelemetry e relate dados ao ARMS (Managed Service for OpenTelemetry). Existem dois métodos disponíveis: instrumentação automática e instrumentação manual.

• A instrumentação automática não exige configurações extras para correlacionar traces com o RUM, pois o OpenTelemetry suporta a maioria dos frameworks mainstream.

  Nota

  Para informações sobre os frameworks Java suportados pelo OpenTelemetry, consulte Report Java application data by using OpenTelemetry.

• Na instrumentação manual, use o mecanismo de extensão do SDK do OpenTelemetry para correlacionar os traces. Esse processo envolve analisar o contexto de trace a partir dos headers traceparent e tracestate das solicitações de frontend. O código abaixo apresenta um exemplo para uma aplicação SpringBoot:

  1. Adicione as dependências do OpenTelemetry.

     <dependency>
       <groupId>io.opentelemetry</groupId>
       <artifactId>opentelemetry-api</artifactId>
     </dependency>
     <dependency>
       <groupId>io.opentelemetry</groupId>
       <artifactId>opentelemetry-sdk-trace</artifactId>
     </dependency>
     <dependency>
       <groupId>io.opentelemetry</groupId>
       <artifactId>opentelemetry-extension-annotations</artifactId>
       <version>1.18.0</version>
     </dependency>
     <dependency>
       <groupId>io.opentelemetry</groupId>
       <artifactId>opentelemetry-exporter-otlp</artifactId>
     </dependency>
     <dependency>
       <groupId>io.opentelemetry</groupId>
       <artifactId>opentelemetry-sdk</artifactId>
     </dependency>
     <dependency>
       <groupId>io.opentelemetry</groupId>
       <artifactId>opentelemetry-semconv</artifactId>
       <version>1.30.1-alpha</version>
     </dependency>
     <dependency>
       <groupId>io.opentelemetry</groupId>
       <artifactId>opentelemetry-sdk-extension-autoconfigure</artifactId>
       <version>1.34.1</version>
     </dependency>
     <dependency>
       <groupId>io.opentelemetry</groupId>
       <artifactId>opentelemetry-extension-incubator</artifactId>
       <version>1.35.0-alpha</version>
     </dependency>

  2. Adicione o propagador W3C durante a inicialização do OpenTelemetry.

     Resource resource = Resource.getDefault()
             .merge(Resource.create(Attributes.of(
                     ResourceAttributes.SERVICE_NAME, "otel-demo",
                     ResourceAttributes.HOST_NAME, "xxxx"
     )));
     
     SdkTracerProvider sdkTracerProvider = SdkTracerProvider.builder()
             .addSpanProcessor(BatchSpanProcessor.builder(OtlpHttpSpanExporter.builder()
                     .setEndpoint("Your Endpoint")
                     .addHeader("Authentication", "Your Token")
                     .build()).build())
             .setResource(resource)
             .build();
     
     openTelemetry = OpenTelemetrySdk.builder()
             .setTracerProvider(sdkTracerProvider)
             // Add the W3C propagator here.
             .setPropagators(ContextPropagators.create(
                     TextMapPropagator.composite(W3CTraceContextPropagator.getInstance(), W3CBaggagePropagator.getInstance()))
              ).buildAndRegisterGlobal();
     // An extended Tracer is required here.
     tracer = ExtendedTracer.create(openTelemetry.getTracer("com.example.tracer", "1.0.0"));

  3. Na interface de negócios, adicione o parâmetro de headers, analise o contexto de trace a partir do header da solicitação e defina o parent.

     // Add the request header parameter in the Controller to parse the trace context.
     @RequestMapping("/test")
     public String test(@RequestHeader Map<String, String> headers) {
         Span span = OpenTelemetrySupport.getTracer()
                 .spanBuilder("/test")
                 // Parse the parent span from the headers.
                 .setParentFrom(OpenTelemetrySupport.getContextPropagators(), headers)
                 .setSpanKind(SpanKind.SERVER)
                 .startSpan();
         try (Scope scope = span.makeCurrent()) {
             // do something
         } catch (Throwable t) {
             span.setStatus(StatusCode.ERROR, "handle parent span error");
         } finally {
             span.end();
         }
         return "success";
     }

SkyWalking

Para o procedimento completo de instrumentação, consulte Java Agent plugin.

Atualmente, o SkyWalking fornece apenas o Java Agent para instrumentação. Basta seguir as instruções no documento vinculado para correlacionar os traces do RUM e do backend.

Correspondência de protocolo: O protocolo sw8 (v3) configurado no lado do RUM corresponde ao agente SkyWalking 8.x.

OpenTelemetry

Para o procedimento completo de instrumentação, consulte Report Go application data by using OpenTelemetry.

Siga a documentação para instrumentar seu aplicativo. Em seguida, gere um span a partir do contexto da solicitação no handler de requisições HTTP para correlacioná-lo com o trace do RUM.

// Initialize the tracer.
tracer := otel.Tracer(common.TraceInstrumentationName)
// Generate a span from the request context.
handler := http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
    ctx := req.Context()
    span := trace.SpanFromContext(ctx)
    // do something
    w.Write([]byte("Hello World"))
})

SkyWalking

Para o procedimento completo de instrumentação, consulte Report Go application data by using SkyWalking.

Siga a documentação para instrumentar seu aplicativo. Recomendamos usar o método skywalking-go, que suporta frameworks web mainstream como Gin, go-restful, http, go-kratos v2, go-micro e go-resty. Isso permite correlacionar traces do RUM sem modificar o código.

Para analisar manualmente o contexto de trace a partir dos headers de solicitação HTTP, utilize o seguinte código:

// Extract context from the 'sw8' HTTP request header.
span, ctx, err := tracer.CreateEntrySpan(r.Context(), "/api/test", func(key string) (string, error) {
		return r.Header.Get(key), nil
})

OpenTelemetry

Para o procedimento completo de instrumentação, consulte Report Python application data by using OpenTelemetry.

Siga a documentação para instrumentar seu aplicativo. Depois, analise o contexto do span a partir dos headers de solicitação HTTP para correlacionar com o trace do RUM. Veja abaixo um exemplo de código:

// Initialize the tracer.
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(BatchSpanProcessor(ConsoleSpanExporter()))

tracer = trace.get_tracer(__name__)

@app.route('/test')
def test():
    headers = dict(request.headers)

    // Parse the trace context from the headers.
    carrier ={'traceparent': headers['Traceparent'], 'tracestate': headers['Tracestate']}
    ctx = TraceContextTextMapPropagator().extract(carrier=carrier)

    with tracer.start_span("test", context=ctx):
        // do something
        return "success"

SkyWalking

Para o procedimento completo de instrumentação, consulte Report Python application data by using SkyWalking.

Siga a documentação para instrumentar seu aplicativo. Em seguida, analise o contexto do span a partir dos headers de solicitação HTTP para correlacionar com o trace do RUM. Confira o exemplo de código a seguir:

from skywalking import config, agent
from skywalking.trace.context import SpanContext, get_context
from skywalking.trace.carrier import CarrierItem

# Configure SkyWalking. Adjust parameters as needed.
config.init(agent_collector_backend_services='<endpoint>',
            agent_authentication='<auth-token>')

agent.start()

# Sample HTTP request handler that requires passing in HTTP request headers.
def handle_request(headers):
    # Extract trace information from the request headers.
    carrier_items = []
    for item in SpanContext.make_carrier():
        carrier_header = headers.get(item.key.lower())
        if carrier_header:
            carrier_items.append(CarrierItem(item.key, carrier_header))

    carrier = SpanContext.make_carrier(carrier_items)

    # Extract the trace context from the carrier.
    context = get_context().extract(carrier)
    
    # Create a new span to process the request.
    with get_context().new_entry_span(op='operation_name') as span:
        # Process the request here. The span is automatically submitted when finished.
        ...

# Simulate a received HTTP request header that includes sw8.
incoming_headers = {
    'sw8': '1-My40LjU=-MTY1MTcwNDI5OTk5OA==-xxxx-xx-x-x==',  # Sample value. Use the actual value from the request.
    # Other headers...
}

# Call the function to process the request.
handle_request(incoming_headers)