OpenTelemetry Java：利用上下文传播构建分布式 Span 关系

import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.context.Context;
import io.opentelemetry.context.Scope;
import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
import io.opentelemetry.context.propagation.TextMapSetter;
import java.util.HashMap;
import java.util.Map;

public class CallerService {

    private final Tracer tracer;
    private final OpenTelemetry openTelemetry;

    public CallerService(OpenTelemetry openTelemetry) {
        this.openTelemetry = openTelemetry;
        this.tracer = openTelemetry.getTracer("my-caller-service");
    }

    /**
     * 模拟一个远程调用，并将当前 Span 的上下文注入到传输载体中。
     * @return 包含追踪上下文的 Map，模拟 HTTP Headers。
     */
    public Map<String, String> makeRemoteCall() {
        Span parentSpan = tracer.spanBuilder("parentSpanInCaller")
            .startSpan();
        Map<String, String> carrier = new HashMap<>(); // 模拟 HTTP Headers 或消息队列元数据

        try (Scope scope = parentSpan.makeCurrent()) {
            // 获取当前上下文，并使用 W3CTraceContextPropagator 将其注入到 carrier 中
            W3CTraceContextPropagator.getInstance().inject(
                Context.current(), // 获取当前活跃的 Span 所在的上下文
                carrier,           // 传输载体，例如一个 Map 来模拟 HTTP Headers
                new TextMapSetter<Map<String, String>>() {
                    @Override
                    public void set(Map<String, String> carrier, String key, String value) {
                        carrier.put(key, value);
                    }
                });
            System.out.println("调用方 Span ID: " + parentSpan.getSpanContext().getSpanId());
            System.out.println("注入的追踪上下文: " + carrier);
        } finally {
            parentSpan.end();
        }
        return carrier;
    }
}

import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.context.Context;
import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
import io.opentelemetry.context.propagation.TextMapGetter;
import java.util.Collections;
import java.util.Map;

public class CalleeService {

    private final Tracer tracer;
    private final OpenTelemetry openTelemetry;

    public CalleeService(OpenTelemetry openTelemetry) {
        this.openTelemetry = openTelemetry;
        this.tracer = openTelemetry.getTracer("my-callee-service");
    }

    /**
     * 模拟处理远程调用，从传输载体中提取上下文，并创建子 Span。
     * @param carrier 包含追踪上下文的 Map，模拟 HTTP Headers。
     */
    public void processRemoteCall(Map<String, String> carrier) {
        // 从 carrier 中提取追踪上下文
        Context extractedContext = W3CTraceContextPropagator.getInstance().extract(
            Context.current(), // 默认上下文，如果 carrier 中没有追踪信息，则使用此上下文
            carrier,           // 传输载体
            new TextMapGetter<Map<String, String>>() {
                @Override
                public Iterable<String> keys(Map<String, String> carrier) {
                    return carrier.keySet();
                }

                @Override
                public String get(Map<String, String> carrier, String key) {
                    return carrier.get(key);
                }
            });

        // 使用提取到的上下文作为新 Span 的父级
        Span childSpan = tracer.spanBuilder("childSpanInCallee")
            .setParent(extractedContext) // 将提取到的上下文设置为父级
            .startSpan();

        try {
            System.out.println("被调用方 Span ID: " + childSpan.getSpanContext().getSpanId());
            System.out.println("被调用方父 Span ID: " + childSpan.getParentSpanContext().getSpanId());
            // 模拟一些工作
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            childSpan.end();
        }
    }
}

import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import io.opentelemetry.sdk.trace.export.ConsoleSpanExporter;
import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
import io.opentelemetry.sdk.trace.samplers.Sampler;
import io.opentelemetry.sdk.resources.Resource;
import io.opentelemetry.semconv.ResourceAttributes;

import java.util.Map;

public class Main {
    public static void main(String[] args) {
        // 1. 配置 OpenTelemetry SDK
        // 定义服务资源，例如服务名称
        Resource serviceResource = Resource.getDefault()
            .toBuilder()
            .put(ResourceAttributes.SERVICE_NAME, "my-distributed-app")
            .build();

        // 配置 TracerProvider，使用 ConsoleSpanExporter 将 Span 输出到控制台
        // 并设置采样器为始终采样
        SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
            .addSpanProcessor(SimpleSpanProcessor.create(ConsoleSpanExporter.create()))
            .setResource(serviceResource)
            .setSampler(Sampler.alwaysOn())
            .build();

        // 构建并注册全局的 OpenTelemetry 实例
        OpenTelemetry openTelemetry = OpenTelemetrySdk.builder()
            .setTracerProvider(tracerProvider)
            // OpenTelemetry SDK 会自动注册 W3CTraceContextPropagator 作为默认的传播器
            // .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance())) // 显式设置传播器
            .buildAndRegisterGlobal();

        // 2. 初始化调用方和被调用方服务
        CallerService caller = new CallerService(openTelemetry);
        CalleeService callee = new CalleeService(openTelemetry);

        // 3. 模拟一次分布式调用
        System.out.println("--- 模拟远程调用开始 ---");
        Map<String, String> propagatedContext = caller.makeRemoteCall(); // 调用方注入上下文
        callee.processRemoteCall(propagatedContext); // 被调用方提取上下文并创建子 Span
        System.out.println("--- 远程调用模拟结束 ---");

        // 4. 关闭 TracerProvider 以确保所有 Span 都被导出
        tracerProvider.shutdown();
    }
}

--- 模拟远程调用开始 ---
调用方 Span ID: 6b3c...
注入的追踪上下文: {traceparent=00-d8b4...-6b3c...-01}
被调用方 Span ID: 7a8b...
被调用方父 Span ID: 6b3c...
--- 远程调用模拟结束 ---