Application Real-Time Monitoring Service:Enable end-to-end tracing for a web application or mini program

Java with OpenTelemetry

1. Add the OpenTelemetry dependencies to your project.

       <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. Configure W3C propagation 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 W3C propagation settings
               .setPropagators(ContextPropagators.create(
                       TextMapPropagator.composite(W3CTraceContextPropagator.getInstance(), W3CBaggagePropagator.getInstance()))
                ).buildAndRegisterGlobal();
   
       // Configure a tracer
       tracer = ExtendedTracer.create(openTelemetry.getTracer("com.example.tracer", "1.0.0"));

3. Parse the trace context from the request headers and create a child span.

       @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()) {
               // Process the request
           } catch (Throwable t) {
               span.setStatus(StatusCode.ERROR, "handle parent span error");
           } finally {
               span.end();
           }
           return "success";
       }

Java with Jaeger

1. Add the Jaeger client dependency.

       <dependency>
         <groupId>io.jaegertracing</groupId>
         <artifactId>jaeger-client</artifactId>
         <version>Latest version</version>
       </dependency>

2. Initialize the tracer. Replace <endpoint> with the endpoint from the Access point information tab on the Cluster Configurations 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();
       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. Parse the trace context and create a child span.

       @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");
               // Process the request
           } catch (Throwable t) {
               TracingHelper.onError(t, span);
               throw t;
           } finally {
               span.finish();
           }
           return "success";
       }

Java with Zipkin

Integrate your application with Managed Service for OpenTelemetry through Zipkin. See Use Zipkin to report Java application data.

Parse the trace context from the request headers:

// Parse the trace context from the request headers
extractor = tracing.propagation().extractor(Request::getHeader);

// Convert the context to a span
oneWayReceive = nextSpan(tracer, extractor.extract(request))
.name("process-request")
.kind(SERVER)
... add tags etc.

// Start the server-side span and flush
oneWayReceive.start().flush();

// Create child spans for follow-up work
next = tracer.newSpan(oneWayReceive.context()).name("step2").start();

Go with OpenTelemetry

Integrate your application with Managed Service for OpenTelemetry. See Use OpenTelemetry to submit the trace data of a Go application.

Generate a span from the request context:

// 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)
    // Process the request
    w.Write([]byte("Hello World"))
})

Go with Jaeger

Integrate your application with Managed Service for OpenTelemetry. See Use Jaeger to report Go application data.

Parse the span context from the HTTP request headers:

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

Go with Zipkin

Integrate your application with Managed Service for OpenTelemetry. See Use Zipkin to submit the trace data of a Go application.

Retrieve the span from the request context:

// 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) {
    span := zipkin.SpanFromContext(r.Context())
    span.Tag("some_key", "some_value")
    // Process the request
    span.Annotate(time.Now(), "some_event")
})

Go with SkyWalking

Integrate your application with Managed Service for OpenTelemetry. See Use SkyWalking to report Go application data.

Parse the trace context from the sw8 header:

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

Python with OpenTelemetry

Integrate your application with Managed Service for OpenTelemetry. See Use OpenTelemetry to report the trace data of Python applications.

Parse the trace context from the traceparent and tracestate headers:

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 request headers
    carrier = {'traceparent': headers['Traceparent'], 'tracestate': headers['Tracestate']}
    ctx = TraceContextTextMapPropagator().extract(carrier=carrier)

    with tracer.start_span("test", context=ctx):
        # Process the request
        return "success"

Python with Jaeger

Integrate your application with Managed Service for OpenTelemetry. See Use Jaeger to report Python application data.

Parse the trace context from the request headers:

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

# Trace decorator
def trace(tracer, span_name):
    def decorator(f):
        @functools.wraps(f)
        def wrapped(*args, **kwargs):
            # Parse the trace context from the request 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

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

Python with SkyWalking

Integrate your application with Managed Service for OpenTelemetry. See Use SkyWalking to report Python application data.

Parse the trace context from the sw8 header:

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

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

agent.start()

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 span
    with get_context().new_entry_span(op='operation_name') as span:
        # Process the request. The span is submitted automatically when complete.
        ...

# Example: simulated incoming request headers
incoming_headers = {
    'sw8': '1-My40LjU=-MTY1MTcwNDI5OTk5OA==-xxxx-xx-x-x==',
}

handle_request(incoming_headers)