使用ARMS應用監控探針接入

ARMS應用監控探針默認集成了對OpenTelemetry協議的支持，因此無需額外配置，即可實現與RUM Trace關聯，但需要確保以下兩點：

• 支持的ARMS應用監控探針版本：2.x、3.x、4.x，為了獲得更好的使用體驗，推薦升級到4.x版本。

• 支持的Web容器和框架：支持Tomcat、Jetty、WebLogic、Undertow等主流Web容器，以及SpringBoot、SpringMVC等框架。支持的完整組件和框架請參見ARMS應用監控支持的Java組件和框架。

ARMS應用監控探針接入操作請參見開始監控Java應用。

使用OpenTelemetry接入

通過OpenTelemetry接入ARMS（可觀測鏈路 OpenTelemetry 版），目前分為兩種方式：自動埋點和手動埋點。

• 自動埋點場景下，由于OpenTelemetry已經支持了絕大多數主流框架，因此，無需額外配置，即可實現與RUM Trace的串聯。

  說明

  OpenTelemetry支持的Java框架，請參見通過OpenTelemetry上報Java應用數據。

• 手動埋點場景下，需要通過OpenTelemetry SDK提供的擴展機制，實現與RUM Trace的串聯，即從前端請求頭（traceparent、tracesate）中，解析出Trace上下文，以下是Springboot場景代碼示例：

  1. 引入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. 在OpenTelemetry初始化時，添加W3C Propagator。

     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)
             // 這里添加W3C Propagator
             .setPropagators(ContextPropagators.create(
                     TextMapPropagator.composite(W3CTraceContextPropagator.getInstance(), W3CBaggagePropagator.getInstance()))
              ).buildAndRegisterGlobal();
     // 這里需要使用擴展的Tracer
     tracer = ExtendedTracer.create(openTelemetry.getTracer("com.example.tracer", "1.0.0"));

  3. 在業務接口中，添加headers參數，并從請求頭中解析Trace上下文，設置parent。

     // Controller中添加請求header參數，用于解析Trace上下文
     @RequestMapping("/test")
     public String test(@RequestHeader Map<String, String> headers) {
         Span span = OpenTelemetrySupport.getTracer()
                 .spanBuilder("/test")
                 // 從headers中解析parent span
                 .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目前針對Web場景，提供了：手動埋點和通過Spring Cloud組件埋點兩種方式。完整接入方式請參見通過Jaeger上報Java應用數據。

• 通過SpringCloud組件埋點情況下，無需額外配置即可與RUM Trace打通。

• 手動埋點場景下，需要自行從前端請求header中解析Trace上下文。代碼配置示例如下：

  1. 引入依賴項。

     <dependency>
       <groupId>io.jaegertracing</groupId>
       <artifactId>jaeger-client</artifactId>
       <version>最新版本</version> <!-- 確保使用最新的Jaeger版本 -->
     </dependency>

  2. 初始化Tracer。

     請將<endpoint>替換成可觀測鏈路 OpenTelemetry 版控制臺集群配置 > 接入點信息頁面相應客戶端和地域的接入點。

     // 將manualDemo替換為您的應用名稱。
     io.jaegertracing.Configuration config = new io.jaegertracing.Configuration("manualDemo");
     io.jaegertracing.Configuration.SenderConfiguration sender = new io.jaegertracing.Configuration.SenderConfiguration();
     // 將 <endpoint> 替換為控制臺概覽頁面上相應客戶端和地域的接入點。
     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. 在業務接口中創建Span，可參考以下代碼進行Trace關聯。

     // Controller中添加請求header參數，由于解析Trace上下文
     @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接入

完整接入方式請參見通過Zipkin上報Java應用數據。

按照文檔接入，然后在服務端代碼中，從Request Header中解析Context，實現與RUM Trace串聯。

// 從request header解析Context
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接入

完整接入方式請參見Java Agent插件。

SkyWalking目前僅提供了Java Agent接入方式，您只需要按照上述文檔接入，即可實現RUM與后端Trace串聯。

和RUM側配置的協議匹配要求：sw8（v3版本）對應SkyWalking 8.x版本探針。

通過OpenTelemetry接入

完整接入方式請參見通過OpenTelemetry上報Go應用數據。

按照文檔接入，然后在HTTP請求Handler中，通過request context生成Span，即可實現與RUM Trace串聯。

// 初始化tracer
tracer := otel.Tracer(common.TraceInstrumentationName)
// 通過request context生成span
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接入

完整接入方式請參見通過Jaeger上報Go應用數據。

按照文檔接入，然后從HTTP請求頭中解析Span上下文，實現與RUM Trace串聯，代碼示例如下：

// 從HTTP對象解析出spanCtx。
spanCtx, _ := tracer.Extract(opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(r.Header))
span := tracer.StartSpan("myspan", opentracing.ChildOf(spanCtx))
...
defer  span.Finish()

通過Zipkin接入

完整接入方式請參見通過Zipkin上報Go應用數據。

按照文檔接入，然后從HTTP請求頭中解析Span上下文，實現與RUM Trace串聯，代碼示例如下：

// 初始化tracer
tracer, err := exampletracer.NewTracer("go-frontend", frontendPort)
// 通過request context生成span
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接入

完整接入方式請參見通過SkyWalking上報Go應用數據。

按照文檔接入，推薦采用skywalking-go接入方式，該方式支持了主流的Web服務框架，如gin、go-restful、http、go-kratos v2、go-micro、go-resty等，無需修改代碼即可實現與RUM Trace串聯。

如果您希望手動從HTTP請求頭中解析出Trace上下文，也可參考以下代碼實現：

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

通過OpenTelemetry接入

完整接入方式請參見通過OpenTelemetry上報Python應用數據。

按照文檔接入，然后從HTTP請求頭中解析Span上下文，實現與RUM Trace串聯，代碼示例如下：

// 初始化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)

    // 從headers中解析trace context
    carrier ={'traceparent': headers['Traceparent'], 'tracestate': headers['Tracestate']}
    ctx = TraceContextTextMapPropagator().extract(carrier=carrier)

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

通過Jaeger接入

完整接入方式請參見通過Jaeger上報Python應用數據。

按照文檔接入，然后從HTTP請求頭中解析Span上下文，實現與RUM Trace串聯，代碼示例如下：

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

## 初始化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):
            ## 從headers中解析trace context 
            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接入

完整接入方式請參見通過SkyWalking上報Python應用數據。

按照文檔接入，然后從HTTP請求頭中解析Span上下文，實現與RUM Trace串聯，代碼示例如下：

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

# 配置 SkyWalking，根據需要調整相關參數
config.init(agent_collector_backend_services='<endpoint>',
            agent_authentication='<auth-token>')

agent.start()

# 示例 HTTP 請求處理函數，需要傳入 HTTP 請求的 headers
def handle_request(headers):
    # 從請求頭 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)

    # 從 Carrier 中提取追蹤上下文
    context = get_context().extract(carrier)
    
    # 創建一個新 Span 來處理請求
    with get_context().new_entry_span(op='operation_name') as span:
        # 在這里處理請求，并在結束時自動提交 Span
        ...

# 模擬接收到的 HTTP 請求 header 包含 sw8
incoming_headers = {
    'sw8': '1-My40LjU=-MTY1MTcwNDI5OTk5OA==-xxxx-xx-x-x==',  # 示例值，實際根據請求填寫
    # 其他 header...
}

# 調用函數處理請求
handle_request(incoming_headers)