Application Real-Time Monitoring Service:Correlate frontend and backend traces

ARMS agent

The ARMS Application Monitoring agent has built-in support for the OpenTelemetry protocol, so no additional configuration is required to correlate with RUM traces. However, you must ensure the following:

• Supported ARMS Application Monitoring agent versions: 2.x, 3.x, and 4.x. For a better experience, we recommend upgrading to version 4.x.

• The agent supports mainstream web containers such as Tomcat, Jetty, WebLogic, and Undertow, and frameworks such as Spring Boot and Spring MVC. For a complete list of supported components and frameworks, see Java Components and Frameworks Supported by Application Monitoring.

For instructions on how to integrate the ARMS Application Monitoring agent, see Start Monitoring a Java Application.

OpenTelemetry

You can integrate your application with ARMS (Managed Service for OpenTelemetry) by using OpenTelemetry. Two methods are available: auto instrumentation and manual instrumentation.

• For auto instrumentation, OpenTelemetry already supports most mainstream frameworks. No extra configuration is needed to correlate with RUM traces.

  Note

  For a list of Java frameworks supported by OpenTelemetry, see Report Java Application Data by Using OpenTelemetry.

• For manual instrumentation, you must use the extension mechanism provided by the OpenTelemetry SDK to correlate with RUM traces. This involves parsing the trace context from the frontend request headers (traceparent, tracestate). The following is a code sample for a Spring Boot scenario:

  1. Add the OpenTelemetry dependencies.

     <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. Add the W3C Propagator during OpenTelemetry initialization.

     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();
     // Use the extended Tracer here.
     tracer = ExtendedTracer.create(openTelemetry.getTracer("com.example.tracer", "1.0.0"));

  3. In your controller method, add a headers parameter and parse the trace context from the request headers to set the parent.

     // Add a request header parameter to 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";
     }

Jaeger

Jaeger provides two methods for web scenarios: manual instrumentation and instrumentation with a Spring Cloud component. For complete integration instructions, see Report Java Application Data by Using Jaeger.

• If you use instrumentation with a Spring Cloud component, no extra configuration is needed to correlate with RUM traces.

• For manual instrumentation, you need to parse the trace context from the frontend request header. See the code below.

  1. Add the dependency.

     <dependency>
       <groupId>io.jaegertracing</groupId>
       <artifactId>jaeger-client</artifactId>
       <version>Latest Version</version> <!-- Make sure to use the latest Jaeger version. -->
     </dependency>

  2. Initialize the Tracer.

     Replace <endpoint> with the endpoint for the corresponding client and region from the Cluster Configurations > Endpoint Information page in the Managed Service for OpenTelemetry console.

     // Replace manualDemo with your application name.
     io.jaegertracing.Configuration config = new io.jaegertracing.Configuration("manualDemo");
     io.jaegertracing.Configuration.SenderConfiguration sender = new io.jaegertracing.Configuration.SenderConfiguration();
     // Replace <endpoint> with the endpoint for the corresponding client and region from the console overview page.
     sender.withEndpoint("<endpoint>");
     config.withSampler(new io.jaegertracing.Configuration.SamplerConfiguration().withType("const").withParam(1));
     config.withReporter(new io.jaegertracing.Configuration.ReporterConfiguration().withSender(sender).withMaxQueueSize(10000));
     GlobalTracer.register(config.getTracer());

  3. Create a span in your business interface. You can refer to the following code to correlate the trace.

     // Add a request header parameter to the Controller to parse the trace context.
     @RequestMapping("/test")
     public String test(@RequestHeader Map<String, String> headers) {
         Tracer tracer = GlobalTracer.get();
         SpanContext parentCtx = tracer.extract(Format.Builtin.HTTP_HEADERS, new TextMapAdapter(headers));
         Span span;
         if (parentCtx != null) {
             span = tracer.buildSpan("/test").asChildOf(parentCtx).start();
         } else {
             span = tracer.buildSpan("/test").start();
         }
         try (Scope ignored = tracer.activateSpan(span)) {
             tracer.activeSpan().setTag("methodName", "test");
             // do something
         } catch (Throwable t) {
             TracingHelper.onError(e, span);
             throw e
         } finally {
             span.finish();
         }
         return "success";
     }

Zipkin

For complete integration instructions, see Report Java Application Data by Using Zipkin.

Follow the integration instructions in the document, then parse the context from the request header in your server-side code to correlate with the RUM trace.

// Extract the context from the request header.
extractor = tracing.propagation().extractor(Request::getHeader);

// convert that context to a span which you can name and add tags to
oneWayReceive = nextSpan(tracer, extractor.extract(request))
.name("process-request")
.kind(SERVER)
... add tags etc.

// start the server side and flush instead of finish
oneWayReceive.start().flush();

// you should not modify this span anymore as it is complete. However,
// you can create children to represent follow-up work.
next = tracer.newSpan(oneWayReceive.context()).name("step2").start();

SkyWalking

For complete integration instructions, see Java Agent Plugin.

SkyWalking integration is handled by a Java agent. You only need to follow the instructions in the document to correlate RUM and backend traces.

To ensure protocol compatibility with RUM, the sw8 (v3) protocol corresponds to the SkyWalking 8.x agent.

OpenTelemetry

For complete integration instructions, see Report Go Application Data by Using OpenTelemetry.

Follow the integration instructions, then generate a span from the request context in the HTTP request handler to correlate with the RUM trace.

// 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"))
})

Jaeger

For complete integration instructions, see Report Go Application Data by Using Jaeger.

Follow the integration instructions, then parse the span context from the HTTP request header to correlate with the RUM trace. See the code below.

// Extract spanCtx from the HTTP object.
spanCtx, _ := tracer.Extract(opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(r.Header))
span := tracer.StartSpan("myspan", opentracing.ChildOf(spanCtx))
...
defer  span.Finish()

Zipkin

For complete integration instructions, see Report Go Application Data by Using Zipkin.

Follow the integration instructions, then parse the span context from the HTTP request header to correlate with the RUM trace. See the code below.

// Initialize the tracer.
tracer, err := exampletracer.NewTracer("go-frontend", frontendPort)
// Generate a span from the request context.
router.Methods("GET").Path("/").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    // retrieve span from context
	span := zipkin.SpanFromContext(r.Context())
    // add some tag
    span.Tag("some_key", "some_value")
    // do something...
	span.Annotate(time.Now(), "some_event")
})

SkyWalking

For complete integration instructions, see Report Go Application Data by Using SkyWalking.

Follow the integration instructions. We recommend using the skywalking-go integration method, which supports mainstream web frameworks such as gin, go-restful, http, go-kratos v2, go-micro, and go-resty, and correlates with RUM traces without requiring code changes.

If you want to manually parse the trace context from the HTTP request header, you can also use the following code:

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

OpenTelemetry

For complete integration instructions, see Report Python Application Data by Using OpenTelemetry.

Follow the integration instructions, then parse the span context from the HTTP request header to correlate with the RUM trace. See the code below.

# 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)

    # Extract 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"

Jaeger

For complete integration instructions, see Report Python Application Data by Using Jaeger.

Follow the integration instructions, then parse the span context from the HTTP request header to correlate with the RUM trace. See the code below.

import logging
from flask import Flask
from jaeger_client import Config
from opentracing.ext import tags
from opentracing.propagation import Format

# Initialize the tracer.
def init_tracer(service, scope_manager=None):
    logging.getLogger('').handlers = []
    logging.basicConfig(format='%(message)s', level=logging.DEBUG)

    config = Config(
        config={
            'sampler': {
                'type': 'const',
                'param': 1,
            },
            'logging': True,
            'reporter_batch_size': 1,
        },
        service_name=service,
        scope_manager=scope_manager
    )
    return config.initialize_tracer()

# The trace decorator.
def trace(tracer, span_name):
    def decorator(f):
        @functools.wraps(f)
        def wrapped(*args, **kwargs):
            # Extract the trace context from headers.
            span_ctx = tracer.extract(Format.HTTP_HEADERS, request.headers)
            span_tags = {tags.SPAN_KIND: tags.SPAN_KIND_RPC_SERVER}

            with tracer.start_active_span(span_name, child_of=span_ctx, tags=span_tags) as scope:
                rv = f(*args, **kwargs)

            return rv
        return wrapped
    return decorator

# API test example.
@app.route('/test')
@trace(tracer, 'test')
def test():
    return "success"

SkyWalking

For complete integration instructions, see Report Python Application Data by Using SkyWalking.

Follow the integration instructions, then parse the span context from the HTTP request header to correlate with the RUM trace. See the code below.

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()

# Example HTTP request handler. Pass the 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 handle the request.
    with get_context().new_entry_span(op='operation_name') as span:
        # Handle the request here. The span is submitted automatically when finished.
        ...

# Simulate received HTTP headers containing sw8.
incoming_headers = {
    'sw8': '1-My40LjU=-MTY1MTcwNDI5OTk5OA==-xxxx-xx-x-x==',  # Example value. Use the actual value from the request.
    # other headers...
}

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