Jaeger Tracing（Open Tracing） 遇到线

Jaeger 在多线程环境下的问题

 线程池可谓 Jaeger 的天敌，因为 Jaeger 不同于 Skywalking 的 Instrument 技术， Jaeger 主要采用 Filter 和 AOP 技术实现 Span 的生成与传递。 而在整个调用生命周期内共享父 Span 则采用的 ThreadLocal 方式。

 ThreadLocal 天生的劣势，多线程环境下就失效（默认实现是 ThreadLocal，开启新线程就失效，甚至没用线程池才失效的 InheritableThreadLocal）。

 而在高性能的服务中，开启线程池进行一些异步处理几乎是无可避免的，这样就会造成调用链不完整，会断裂成多段。

解决方案

 在 Jaeger 的 贡献库中有人通过扩展 jdk 线程池的方式解决了这个问题，然而这种方式会造成大量现有代码的改动，显然不是最优方式。
https://github.com/opentracing-contrib/java-concurrent

Best Practice

 说到 ThreadLocal 不能跨线程传递的问题，阿里的大佬们早就解决了这个问题，就是大名鼎鼎的 TTL（https://github.com/alibaba/transmittable-thread-local）。这里他正好可以派上用场！
 现在具体分析为什么多线程环境下 Jaeger 调用链会断裂
其实就两个关键类：ThreadLocalScope 和 ThreadLocalScopeManager，看看里面都干了啥

• io.opentracing.util.ThreadLocalScope

public class ThreadLocalScope implements Scope {
    private final ThreadLocalScopeManager scopeManager;
    private final Span wrapped;
    private final boolean finishOnClose;
    private final ThreadLocalScope toRestore;

    ThreadLocalScope(ThreadLocalScopeManager scopeManager, Span wrapped, boolean finishOnClose) {
        this.scopeManager = scopeManager;
        this.wrapped = wrapped;
        this.finishOnClose = finishOnClose;
        this.toRestore = scopeManager.tlsScope.get();
        scopeManager.tlsScope.set(this);
    }

    @Override
    public void close() {
        if (scopeManager.tlsScope.get() != this) {
            // This shouldn't happen if users call methods in the expected order. Bail out.
            return;
        }

        if (finishOnClose) {
            wrapped.finish();
        }

        scopeManager.tlsScope.set(toRestore);
    }

    @Override
    public Span span() {
        return wrapped;
    }
}

• io.opentracing.util.ThreadLocalScopeManager

public class ThreadLocalScopeManager implements ScopeManager {
    final ThreadLocal<ThreadLocalScope> tlsScope = new ThreadLocal<ThreadLocalScope>();

    @Override
    public Scope activate(Span span, boolean finishOnClose) {
        return new ThreadLocalScope(this, span, finishOnClose);
    }

    @Override
    public Scope active() {
        return tlsScope.get();
    }
}

很明显，问题就出在

ThreadLocal<ThreadLocalScope> tlsScope = new ThreadLocal<ThreadLocalScope>()

找到问题就该 TTL 出场了，稍微改动一下

• TTLScopeManager.java

public class TTLScopeManager implements ScopeManager {
    final TransmittableThreadLocal<TTLScope> ttlScope = new TransmittableThreadLocal();

    public TTLScopeManager() {
    }

    @Override
    public Scope activate(Span span, boolean finishOnClose) {
        return new TTLScope(this, span, finishOnClose);
    }

    @Override
    public Scope active() {
        return (Scope)this.ttlScope.get();
    }
}

• TTLScope

public class TTLScope implements Scope {

    private final TTLScopeManager scopeManager;
    private final Span wrapped;
    private final boolean finishOnClose;
    private final TTLScope toRestore;

    TTLScope(TTLScopeManager scopeManager, Span wrapped, boolean finishOnClose) {
        this.scopeManager = scopeManager;
        this.wrapped = wrapped;
        this.finishOnClose = finishOnClose;
        this.toRestore = (TTLScope)scopeManager.ttlScope.get();
        scopeManager.ttlScope.set(this);
    }

    @Override
    public void close() {
        if(this.scopeManager.ttlScope.get() == this) {
            if(this.finishOnClose) {
                this.wrapped.finish();
            }

            this.scopeManager.ttlScope.set(this.toRestore);
        }
    }

    @Override
    public Span span() {
        return this.wrapped;
    }
}

然后在 Spring 中重新注册 Tracer， 使用我们自定义的 TTLScopeManager

    @Bean("tracer")
    public Tracer tracer(PrometheusMeterRegistry registry) {
        Metrics.addRegistry(registry);
        MicrometerMetricsFactory metricsFactory = new MicrometerMetricsFactory();
        io.jaegertracing.Configuration configuration = new io.jaegertracing.Configuration(appName);
        return configuration.getTracerBuilder()
                .withMetricsFactory(metricsFactory)
                .withScopeManager(new TTLScopeManager())
                .build();
    }

仅仅这样做当然还是不够的，虽然使用了 TransmittableThreadLocal 在跨线程的时候依然取不到，对 TTL 有所了解的同学一定知道，除了使用 TransmittableThreadLocal 我们还要使用修饰过的 TTLRunable 或者 TTLExecutor 那和上面说的 TracedExecutor 有上面区别呢？ 还是涉及大量现有代码改动。

幸好，TTL为我们提供了代码无侵入的 Java Agent 方式。

-javaagent:/path/to/transmittable-thread-local-2.10.2.jar