// Java实现示例：基于Brave框架的上下文传播
public class TraceContextPropagator {
    private final Tracer tracer;

    public void inject(Context context, Carrier carrier) {
        Span currentSpan = tracer.currentSpan();
        if (currentSpan != null) {
            TraceContext traceContext = currentSpan.context();
            carrier.put("traceparent", 
                String.format("00-%s-%s-%02x",
                    traceContext.traceIdString(),
                    traceContext.spanIdString(),
                    traceContext.sampled() ? 0x01 : 0x00));
        }
    }

    public Context extract(Carrier carrier) {
        String traceParent = carrier.get("traceparent");
        if (traceParent != null) {
            // 解析W3C TraceParent格式
            String[] parts = traceParent.split("-");
            if (parts.length == 4) {
                TraceContext context = TraceContext.newBuilder()
                    .traceId(parts[1])
                    .spanId(parts[2])
                    .sampled((Integer.parseInt(parts[3], 16) & 0x01) == 0x01)
                    .build();
                return Context.root().withValue(TRACE_CONTEXT_KEY, context);
            }
        }
        return Context.root();
    }
}

// 线程局部存储与内存可见性保证
public class ThreadLocalTraceContext {
    private static final ThreadLocal<TraceContext> CURRENT_CONTEXT = 
        new ThreadLocal<>();

    // 使用volatile确保跨线程可见性
    private volatile TraceContext asyncContext;

    public void executeAsync(Runnable task) {
        TraceContext current = CURRENT_CONTEXT.get();
        // 通过内存屏障确保上下文正确传递
        CompletableFuture.runAsync(() -> {
            // 在异步线程中恢复上下文
            CURRENT_CONTEXT.set(current);
            try {
                task.run();
            } finally {
                CURRENT_CONTEXT.remove();
            }
        });
    }
}

// 基于概率的采样决策器
public class ProbabilitySampler implements Sampler {
    private final double probability;
    private final Random random;

    public ProbabilitySampler(double probability) {
        this.probability = probability;
        this.random = new Random();
    }

    @Override
    public boolean isSampled(long traceId) {
        // 使用traceId作为随机种子保证一致性
        Random traceRandom = new Random(traceId);
        return traceRandom.nextDouble() < probability;
    }
}

// 令牌桶算法的速率限制采样
public class RateLimitingSampler implements Sampler {
    private final RateLimiter rateLimiter;

    public RateLimitingSampler(int samplesPerSecond) {
        this.rateLimiter = RateLimiter.create(samplesPerSecond);
    }

    @Override
    public boolean isSampled(long traceId) {
        return rateLimiter.tryAcquire();
    }
}

// Span数据的Protobuf序列化
message Span {
    string trace_id = 1;
    string span_id = 2;
    string parent_span_id = 3;
    string name = 4;
    int64 start_time = 5;
    int64 end_time = 6;
    map<string, string> tags = 7;
    repeated Log logs = 8;
}

public class SpanSerializer {
    public byte[] serialize(Span span) {
        SpanProto.Builder builder = SpanProto.newBuilder()
            .setTraceId(span.getTraceId())
            .setSpanId(span.getSpanId())
            .setName(span.getName())
            .setStartTime(span.getStartTime())
            .setEndTime(span.getEndTime());

        // 标签序列化
        span.getTags().forEach((k, v) -> 
            builder.putTags(k, v));

        return builder.build().toByteArray();
    }
}

// Span对象池实现
public class SpanPool {
    private final ObjectPool<Span> pool;

    public SpanPool() {
        this.pool = new GenericObjectPool<>(new SpanFactory());
    }

    public Span borrowSpan() throws Exception {
        return pool.borrowObject();
    }

    public void returnSpan(Span span) {
        span.reset(); // 重置状态复用对象
        pool.returnObject(span);
    }

    private static class SpanFactory extends BasePooledObjectFactory<Span> {
        @Override
        public Span create() {
            return new Span();
        }

        @Override
        public PooledObject<Span> wrap(Span span) {
            return new DefaultPooledObject<>(span);
        }
    }
}

// 基于Disruptor的无锁队列
public class SpanDisruptor {
    private final RingBuffer<SpanEvent> ringBuffer;
    private final EventTranslatorOneArg<SpanEvent, Span> translator;

    public SpanDisruptor(int bufferSize) {
        this.ringBuffer = RingBuffer.createSingleProducer(
            SpanEvent::new, bufferSize, new SleepingWaitStrategy());
        this.translator = (event, sequence, span) -> event.setSpan(span);
    }

    public void publish(Span span) {
        ringBuffer.publishEvent(translator, span);
    }
}

# application-tracing.yml
management:
  tracing:
    sampling:
      probability: 0.1
    baggage:
      remote-fields: version,user-id,device-id
    propagation:
      type: W3C

brave:
  sampler:
    rate: 10
  sender:
    type: http
    url: http://collector:9411/api/v2/spans
    connect-timeout: 5000
    read-timeout: 10000

spring:
  sleuth:
    async:
      enabled: true
    baggage:
      correlation:
        enabled: true
        fields: version,user-id

# settings.py
OPENTRACING_TRACING = {
    'default': 'jaeger',
    'jaeger': {
        'service_name': 'django-app',
        'config': {
            'sampler': {
                'type': 'const',
                'param': 1,
            },
            'local_agent': {
                'reporting_host': 'jaeger-agent',
                'reporting_port': 6831,
            },
            'logging': True,
        },
    },
}

MIDDLEWARE = [
    'django_opentracing.OpenTracingMiddleware',
    # ... 其他中间件
]

# 自定义追踪配置
from jaeger_client import Config

tracer_config = Config(
    config={
        'sampler': {
            'type': 'probabilistic',
            'param': 0.1,
        },
        'logging': True,
    },
    service_name='django-app',
)
tracer = tracer_config.initialize_tracer()

class ModelInferenceSpan:
    def __init__(self, model_name, model_version):
        self.span = tracer.start_span('model_inference')
        self.span.set_tag('model.name', model_name)
        self.span.set_tag('model.version', model_version)

    def record_gpu_metrics(self, gpu_util, memory_used):
        self.span.log({
            'gpu_utilization': gpu_util,
            'gpu_memory_used': memory_used
        })

    def record_input_features(self, feature_count):
        self.span.set_tag('input.features', feature_count)