Application Real-Time Monitoring Service：Aktifkan pelacakan ujung ke ujung untuk aplikasi web atau program mini

Gunakan agen ARMS

Secara default, agen ARMS mendukung protokol OpenTelemetry. Oleh karena itu, pelacakan diimplementasikan untuk aplikasi yang dipantau di Pemantauan Aplikasi tanpa konfigurasi tambahan. Namun, pastikan kondisi berikut terpenuhi:

• Versi agen ARMS adalah V2.x, V3.x, atau V4.x. Kami menyarankan Anda menggunakan V4.x untuk pengalaman pengguna yang lebih baik.

• Web container arus utama, seperti Apache Tomcat, Jetty, WebLogic, atau Undertow, dan framework yang didukung, seperti Spring Boot atau Spring Web MVC, digunakan. Untuk informasi lebih lanjut tentang komponen dan framework yang didukung oleh ARMS, lihat Komponen dan Framework Java yang Didukung oleh ARMS.

Untuk informasi tentang cara menginstal agen ARMS untuk aplikasi, lihat Pantau Aplikasi Java.

Gunakan OpenTelemetry

Anda dapat mengintegrasikan aplikasi ke dalam Managed Service for OpenTelemetry melalui OpenTelemetry dan secara otomatis atau manual instrumentasi aplikasi.

• Jika Anda secara otomatis instrumentasi aplikasi, pelacakan dapat diimplementasikan tanpa konfigurasi tambahan karena OpenTelemetry mendukung sebagian besar framework arus utama.

  Catatan

  Untuk informasi tentang framework Java yang didukung oleh OpenTelemetry, lihat Gunakan OpenTelemetry untuk Melaporkan Data Jejak Aplikasi Java.

• Jika Anda secara manual instrumentasi aplikasi, Anda perlu menggunakan SDK OpenTelemetry untuk mengaktifkan pelacakan dengan menguraikan konteks jejak dari header permintaan frontend traceparent dan tracestate. Kode contoh berikut menunjukkan cara secara manual instrumentasi aplikasi Spring Boot dan mengaktifkan pelacakan.

  1. Impor dependensi 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. Konfigurasikan propagasi W3C selama inisialisasi 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 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";
     }

Gunakan Jaeger

Anda dapat menggunakan Jaeger untuk mengintegrasikan aplikasi ke dalam Managed Service for OpenTelemetry. Jaeger menyediakan dua metode untuk mengaktifkan pelacakan untuk aplikasi web: instrumentasi manual dan instrumentasi melalui komponen Spring Cloud. Untuk informasi lebih lanjut, lihat Gunakan Jaeger untuk Melaporkan Data Aplikasi Java.

• Jika Anda menginstrumentasi aplikasi melalui komponen Spring Cloud, pelacakan dapat diimplementasikan tanpa konfigurasi tambahan.

• Jika Anda secara manual menginstrumentasi aplikasi, Anda harus menguraikan konteks jejak dari header permintaan frontend. Contoh kode:

  1. Impor dependensi.

     <dependency>
       <groupId>io.jaegertracing</groupId>
       <artifactId>jaeger-client</artifactId>
       <version>Latest version</version> <!-- Pastikan versi Jaeger terbaru digunakan. -->
     </dependency>

  2. Inisialisasi tracer.

     Ganti <endpoint> dengan endpoint yang ditampilkan pada tab Access point information halaman Cluster Configurations di konsol Managed Service for OpenTelemetry.

     // Ganti manualDemo dengan nama aplikasi Anda.
     io.jaegertracing.Configuration config = new io.jaegertracing.Configuration("manualDemo");
     io.jaegertracing.Configuration.SenderConfiguration sender = new io.jaegertracing.Configuration.SenderConfiguration();
     // Ganti <endpoint> dengan endpoint yang ditampilkan pada tab Informasi titik akses halaman Konfigurasi Kluster di konsol Managed Service for OpenTelemetry.
     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. Buat 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";
     }

Gunakan Zipkin

Anda dapat menggunakan Zipkin untuk mengintegrasikan aplikasi ke dalam Managed Service for OpenTelemetry. Untuk informasi lebih lanjut, lihat Gunakan Zipkin untuk Melaporkan Data Aplikasi Java.

Kemudian, uraikan konteks jejak dari header permintaan untuk mengaktifkan pelacakan. Contoh kode:

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

Gunakan SkyWalking

Anda dapat menggunakan agen SkyWalking untuk Java untuk mengintegrasikan aplikasi ke dalam Managed Service for OpenTelemetry. Untuk informasi lebih lanjut, lihat Gunakan SkyWalking untuk Melaporkan Data Aplikasi Java.

Kemudian, Anda dapat mengaktifkan pelacakan untuk backend.

Jika Anda menggunakan agen SkyWalking untuk Java V8.x, SkyWalking Cross Process Propagation Headers Protocol v3 (sw8) harus digunakan.

Gunakan OpenTelemetry

Anda dapat menggunakan OpenTelemetry untuk mengintegrasikan aplikasi ke dalam Managed Service for OpenTelemetry. Untuk informasi lebih lanjut, lihat Gunakan OpenTelemetry untuk Mengirimkan Data Jejak Aplikasi Go.

Kemudian, gunakan handler permintaan HTTP untuk menghasilkan span dari konteks permintaan dan mengaktifkan pelacakan. Contoh kode:

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

Gunakan Jaeger

Anda dapat menggunakan Jaeger untuk mengintegrasikan aplikasi ke dalam Managed Service for OpenTelemetry. Untuk informasi lebih lanjut, lihat Gunakan Jaeger untuk Melaporkan Data Aplikasi Go.

Kemudian, uraikan konteks span dari header permintaan HTTP untuk mengaktifkan pelacakan. Contoh kode:

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

Gunakan Zipkin

Anda dapat menggunakan Zipkin untuk mengintegrasikan aplikasi ke dalam Managed Service for OpenTelemetry. Untuk informasi lebih lanjut, lihat Gunakan Zipkin untuk Mengirimkan Data Jejak Aplikasi Go.

Kemudian, uraikan konteks span dari header permintaan HTTP untuk mengaktifkan pelacakan. Contoh kode:

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

Gunakan SkyWalking

Anda dapat menggunakan SkyWalking untuk mengintegrasikan aplikasi ke dalam Managed Service for OpenTelemetry. Untuk informasi lebih lanjut, lihat Gunakan SkyWalking untuk melaporkan data aplikasi Go.

Disarankan untuk menggunakan agen SkyWalking untuk Go, yang mendukung berbagai framework web utama seperti Gin, go-restful, http, Kratos v2, Go Micro, dan Go Resty. Dengan ini, pelacakan dapat diimplementasikan tanpa perlu memodifikasi kode.

Selain itu, Anda dapat secara manual menguraikan konteks jejak dari header permintaan HTTP. Berikut adalah contoh kode:

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

Gunakan OpenTelemetry

Anda dapat menggunakan OpenTelemetry untuk mengintegrasikan aplikasi ke dalam Managed Service for OpenTelemetry. Untuk informasi lebih lanjut, lihat Gunakan OpenTelemetry untuk Melaporkan Data Jejak Aplikasi Python.

Kemudian, uraikan konteks span dari header permintaan HTTP untuk mengaktifkan pelacakan. Contoh kode:

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

Gunakan Jaeger

Anda dapat menggunakan Jaeger untuk mengintegrasikan aplikasi ke dalam Managed Service for OpenTelemetry. Untuk informasi lebih lanjut, lihat Gunakan Jaeger untuk Melaporkan Data Aplikasi Python.

Kemudian, uraikan konteks span dari header permintaan HTTP untuk mengaktifkan pelacakan. Contoh kode:

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"

Gunakan SkyWalking

Anda dapat menggunakan SkyWalking untuk mengintegrasikan aplikasi ke dalam Managed Service for OpenTelemetry. Untuk informasi lebih lanjut, lihat Gunakan SkyWalking untuk Melaporkan Data Aplikasi Python.

Kemudian, uraikan konteks span dari header permintaan HTTP untuk mengaktifkan pelacakan. Contoh kode:

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)