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

Use the ARMS agent

By default, the ARMS agent supports the OpenTelemetry protocol. Therefore, tracing is implemented for applications monitored in Application Monitoring without additional configurations. However, make sure that the following conditions are met:

• The version of the ARMS agent is V2.x, V3.x, or V4.x. We recommend that you use V4.x for better user experience.

• A mainstream web container, such as Apache Tomcat, Jetty, WebLogic, or Undertow, and a supported framework, such as Spring Boot or Spring Web MVC, are used. For more information about the components and frameworks supported by ARMS, see Java components and frameworks supported by ARMS.

For information about how to install an ARMS agent for an application, see Monitor Java applications.

Use OpenTelemetry

You can integrate an application into Managed Service for OpenTelemetry through OpenTelemetry and automatically or manually instrument the application.

• If you automatically instrument the application, tracing can be implemented without additional configurations because OpenTelemetry supports most mainstream frameworks.

  Note

  For information about the Java frameworks supported by OpenTelemetry, see Use OpenTelemetry to report the trace data of Java applications.

• If you manually instrument the application, you need to use OpenTelemetry SDKs to enable tracing by parsing the trace context from the frontend request headers traceparent and tracestate. The following sample code shows how to manually instrument a Spring Boot application and enable tracing.

  1. Import 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. 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. Obtain header information, parse the trace context, and configure the parent span.

     // Obtain header information in @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";
     }

Use Jaeger

You can use Jaeger to integrate an application into Managed Service for OpenTelemetry. Jaeger provides two methods for enabling tracing for web applications: manual instrumentation and instrumentation through the Spring Cloud component. For more information, see Use Jaeger to report Java application data.

• If you instrument an application through the Spring Cloud component, tracing can be implemented without additional configurations.

• If you manually instrument an application, you must parse the trace context from the frontend request headers. Sample code:

  1. Import dependencies.

     <dependency>
       <groupId>io.jaegertracing</groupId>
       <artifactId>jaeger-client</artifactId>
       <version>Latest version</version> <!-- Make sure that the latest Jaeger version is used. -->
     </dependency>

  2. Initialize the tracer.

     Replace <endpoint> with the endpoint displayed on the Access point information tab of 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();
     // Replace <endpoint> with the endpoint that is displayed on the Access point information tab of the Cluster Configurations page in the Managed Service for OpenTelemetry console. 
     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.

     // Obtain header information in @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";
     }

Use Zipkin

You can use Zipkin to integrate an application into Managed Service for OpenTelemetry. For more information, see Use Zipkin to report Java application data.

Then, parse the trace context from the request headers to enable tracing. Sample code:

// Parse the trace context from the request headers.
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();

Use SkyWalking

You can use an SkyWalking agent for Java to integrate an application into Managed Service for OpenTelemetry. For more information, see Use SkyWalking to report Java application data.

Then, you can enable tracing for the backend.

If you use an SkyWalking agent for Java V8.x, SkyWalking Cross Process Propagation Headers Protocol v3 (sw8) must be used.

Use OpenTelemetry

You can use OpenTelemetry to integrate an application into Managed Service for OpenTelemetry. For more information, see Use OpenTelemetry to submit the trace data of a Go application.

Then, use an HTTP request handler to generate a span from the request context and enable tracing. Sample code:

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

Use Jaeger

You can use Jaeger to integrate an application into Managed Service for OpenTelemetry. For more information, see Use Jaeger to report Go application data.

Then, parse the span context from the HTTP request headers to enable tracing. Sample code:

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

Use Zipkin

You can use Zipkin to integrate an application into Managed Service for OpenTelemetry. For more information, see Use Zipkin to submit the trace data of a Go application.

Then, parse the span context from the HTTP request headers to enable tracing. Sample code:

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

Use SkyWalking

You can use SkyWalking to integrate an application into Managed Service for OpenTelemetry. For more information, see Use SkyWalking to report Go application data.

We recommend that you use a SkyWalking agent for Go, which supports mainstream web frameworks, such as Gin, go-restful, http, Kratos v2, Go Micro, and Go Resty. Then, tracing can be implemented without modifying the code.

You can also manually parse the trace context from the HTTP request headers. Sample code:

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

Use OpenTelemetry

You can use OpenTelemetry to integrate an application into Managed Service for OpenTelemetry. For more information, see Use OpenTelemetry to report the trace data of Python applications.

Then, parse the span context from the HTTP request headers to enable tracing. Sample code:

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

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

Use Jaeger

You can use Jaeger to integrate an application into Managed Service for OpenTelemetry. For more information, see Use Jaeger to report Python application data.

Then, parse the span context from the HTTP request headers to enable tracing. Sample code:

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

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

Use SkyWalking

You can use SkyWalking to integrate an application into Managed Service for OpenTelemetry. For more information, see Use SkyWalking to report Python application data.

Then, parse the span context from the HTTP request headers to enable tracing. Sample code:

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

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

agent.start()

# Use the function to process the HTTP request headers.
def handle_request(headers):
    # Obtain the 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)

    # Obtain 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 and automatically submit the span upon processing completion.
        ...

# Use a dictionary with SkyWalking segment IDs to simulate the HTTP request headers.
incoming_headers = {
    'sw8': '1-My40LjU=-MTY1MTcwNDI5OTk5OA==-xxxx-xx-x-x==',  # Specify the value.
    # Other headers...
}

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