opentracing-contrib/java-spring-cloud#92 Standard logging integration

DiagnosticContextScopeManager.java

import io.opentracing.Scope;
import io.opentracing.ScopeManager;
import io.opentracing.Span;
import org.slf4j.MDC;
import org.springframework.lang.Nullable;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

public class DiagnosticContextScopeManager implements ScopeManager {

    private final ScopeManager scopeManager;
    private final SpanDiagnosticContext spanDiagnosticContext;

    public DiagnosticContextScopeManager(ScopeManager scopeManager, SpanDiagnosticContext spanDiagnosticContext) {
        this.scopeManager = Objects.requireNonNull(scopeManager);
        this.spanDiagnosticContext = Objects.requireNonNull(spanDiagnosticContext);
    }

    @Override
    public Scope activate(Span span, boolean finishSpanOnClose) {
        // Activate scope
        Scope scope = scopeManager.activate(span, finishSpanOnClose);
        Map<String, String> context = spanDiagnosticContext.create(scope.span());

        // Return wrapper
        return new DiagnosticContextScope(scope, context);
    }

    @Nullable
    @Override
    public Scope active() {
        return scopeManager.active();
    }

    /**
     * Wrapper class for {@link Scope}, which also closes attached {@link SpanDiagnosticContext}.
     * <p>
     * Created by {@link DiagnosticContextScopeManager}.
     */
    public static class DiagnosticContextScope implements Scope {

        private final Scope scope;
        private final Map<String, String> previous = new HashMap<>();

        public DiagnosticContextScope(Scope scope, Map<String, String> context) {
            this.scope = scope;

            // Initialize MDC
            for (Map.Entry<String, String> entry : context.entrySet()) {
                this.previous.put(entry.getKey(), MDC.get(entry.getKey()));
                mdcReplace(entry.getKey(), entry.getValue());
            }
        }

        @Override
        public void close() {
            // Close
            scope.close();

            // Restore previous context
            for (Map.Entry<String, String> entry : previous.entrySet()) {
                mdcReplace(entry.getKey(), entry.getValue());
            }
        }

        @Nullable
        @Override
        public Span span() {
            return scope.span();
        }

        private static void mdcReplace(String key, @Nullable String value) {
            if (value != null) {
                MDC.put(key, value);
            } else {
                MDC.remove(key);
            }
        }
    }
}

JaegerDiagnosticContext.java

import com.uber.jaeger.SpanContext;
import io.opentracing.Span;
import java.util.HashMap;
import java.util.Map;

public class JaegerDiagnosticContext implements SpanDiagnosticContext {

    @Override
    public Map<String, String> create(Span span) {
        // Get Jaeger context
        SpanContext spanContext = (SpanContext) span.context();

        // Prepare context map
        Map<String, String> contextMap = new HashMap<>(3);
        contextMap.put("traceId", Long.toHexString(spanContext.getTraceId()));
        contextMap.put("spanId", Long.toHexString(spanContext.getSpanId()));
        contextMap.put("flags", Integer.toHexString(spanContext.getFlags()));

        return contextMap;
    }
}

JaegerDiagnosticContextTracerBuilderCustomizer.java

import com.uber.jaeger.Tracer;
import io.opentracing.ScopeManager;
import io.opentracing.contrib.spring.cloud.starter.jaeger.TracerBuilderCustomizer;
import io.opentracing.util.ThreadLocalScopeManager;
import org.springframework.lang.NonNull;

public class JaegerDiagnosticContextTracerBuilderCustomizer implements TracerBuilderCustomizer {

    private final ScopeManager scopeManager;
    private final SpanDiagnosticContext spanDiagnosticContext;

    public JaegerDiagnosticContextTracerBuilderCustomizer(@NonNull SpanDiagnosticContext spanDiagnosticContext) {
        scopeManager = new ThreadLocalScopeManager();
        this.spanDiagnosticContext = spanDiagnosticContext;
    }

    public JaegerDiagnosticContextTracerBuilderCustomizer(@NonNull ScopeManager scopeManager, @NonNull SpanDiagnosticContext spanDiagnosticContext) {
        this.scopeManager = scopeManager;
        this.spanDiagnosticContext = spanDiagnosticContext;
    }

    @Override
    public void customize(Tracer.Builder builder) {
        builder.withScopeManager(new DiagnosticContextScopeManager(scopeManager, spanDiagnosticContext));
    }
}

SpanDiagnosticContext.java

import io.opentracing.Span;
import java.util.Map;

@FunctionalInterface
public interface SpanDiagnosticContext {

    Map<String, String> create(Span span);
}

TracerDiagnosticContextAutoConfiguration.java

import io.opentracing.contrib.spring.cloud.starter.jaeger.TracerBuilderCustomizer;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class TracerDiagnosticContextAutoConfiguration {

    @Configuration
    @ConditionalOnClass(TracerBuilderCustomizer.class)
    public static class JaegerDiagnosticContextConfiguration {

        @Bean
        @ConditionalOnMissingBean(SpanDiagnosticContext.class)
        public JaegerDiagnosticContext jaegerDiagnosticContext() {
            return new JaegerDiagnosticContext();
        }

        @Bean
        public TracerBuilderCustomizer diagnosticContextTracerBuilderCustomizer(SpanDiagnosticContext spanDiagnosticContext) {
            return new JaegerDiagnosticContextTracerBuilderCustomizer(spanDiagnosticContext);
        }
    }
}