Merge pull request #6824 from pavolloffay/jaeger-reconfigurable

Make Jaeger tracer reconfigurable

extensions/jaeger/deployment/src/main/java/io/quarkus/jaeger/deployment/JaegerProcessor.java

@@ -11,6 +11,7 @@ import io.quarkus.deployment.builditem.FeatureBuildItem;
 import io.quarkus.jaeger.runtime.JaegerBuildTimeConfig;
 import io.quarkus.jaeger.runtime.JaegerConfig;
 import io.quarkus.jaeger.runtime.JaegerDeploymentRecorder;
+import io.quarkus.runtime.ApplicationConfig;
 
 public class JaegerProcessor {
 
@@ -19,13 +20,14 @@ public class JaegerProcessor {
 
     @BuildStep
     @Record(ExecutionTime.RUNTIME_INIT)
-    void setupTracer(JaegerDeploymentRecorder jdr, JaegerBuildTimeConfig buildTimeConfig, JaegerConfig jaeger) {
+    void setupTracer(JaegerDeploymentRecorder jdr, JaegerBuildTimeConfig buildTimeConfig, JaegerConfig jaeger,
+            ApplicationConfig appConfig) {
 
         // Indicates that this extension would like the SSL support to be enabled
         extensionSslNativeSupport.produce(new ExtensionSslNativeSupportBuildItem(FeatureBuildItem.JAEGER));
 
         if (buildTimeConfig.enabled) {
-            jdr.registerTracer(jaeger);
+            jdr.registerTracer(jaeger, appConfig);
         }
     }
 

extensions/jaeger/runtime/src/main/java/io/quarkus/jaeger/runtime/JaegerDeploymentRecorder.java

@@ -1,45 +1,38 @@
 package io.quarkus.jaeger.runtime;
 
-import static io.jaegertracing.Configuration.JAEGER_SERVICE_NAME;
-
 import java.util.Optional;
 import java.util.function.Function;
 
-import org.eclipse.microprofile.config.Config;
-import org.eclipse.microprofile.config.ConfigProvider;
 import org.jboss.logging.Logger;
 
 import io.opentracing.util.GlobalTracer;
+import io.quarkus.runtime.ApplicationConfig;
 import io.quarkus.runtime.annotations.Recorder;
 
 @Recorder
 public class JaegerDeploymentRecorder {
-    private static volatile boolean registered;
-
     private static final Logger log = Logger.getLogger(JaegerDeploymentRecorder.class);
+    private static final Optional UNKNOWN_SERVICE_NAME = Optional.of("quarkus/unknown");
+    private static final QuarkusJaegerTracer quarkusTracer = new QuarkusJaegerTracer();
 
-    public void registerTracer(JaegerConfig jaeger) {
-        if (!registered) {
-            if (isValidConfig(jaeger)) {
-                initTracerConfig(jaeger);
-                QuarkusJaegerTracer quarkusJaegerTracer = new QuarkusJaegerTracer();
-                log.debugf("Registering tracer to GlobalTracer %s", quarkusJaegerTracer);
-                GlobalTracer.register(quarkusJaegerTracer);
+    synchronized public void registerTracer(JaegerConfig jaeger, ApplicationConfig appConfig) {
+        if (!jaeger.serviceName.isPresent()) {
+            if (appConfig.name.isPresent()) {
+                jaeger.serviceName = appConfig.name;
+            } else {
+                jaeger.serviceName = UNKNOWN_SERVICE_NAME;
             }
-            registered = true;
         }
-    }
-
-    private boolean isValidConfig(JaegerConfig jaeger) {
-        Config mpconfig = ConfigProvider.getConfig();
-        Optional<String> serviceName = mpconfig.getOptionalValue(JAEGER_SERVICE_NAME, String.class);
-        if (!jaeger.serviceName.isPresent() && !serviceName.isPresent()) {
-            log.warn(
-                    "Jaeger service name has not been defined, either as 'quarkus.jaeger.service-name' application property or JAEGER_SERVICE_NAME environment variable/system property");
-        } else {
-            return true;
+        initTracerConfig(jaeger);
+        quarkusTracer.reset();
+        // register Quarkus tracer to GlobalTracer.
+        // Usually the tracer will be registered only here, although consumers
+        // could register a different tracer in the code which runs before this class.
+        // This is also used in tests.
+        if (!GlobalTracer.isRegistered()) {
+            log.debugf("Registering tracer to GlobalTracer %s", quarkusTracer);
+            GlobalTracer.register(quarkusTracer);
         }
-        return false;
     }
 
     private void initTracerConfig(JaegerConfig jaeger) {
@@ -60,8 +53,7 @@ public class JaegerDeploymentRecorder {
         initTracerProperty("JAEGER_TAGS", jaeger.tags, tags -> tags.toString());
         initTracerProperty("JAEGER_PROPAGATION", jaeger.propagation, format -> format.toString());
         initTracerProperty("JAEGER_SENDER_FACTORY", jaeger.senderFactory, sender -> sender);
-        initTracerProperty(QuarkusJaegerTracer.LOG_TRACE_CONTEXT, Optional.of(jaeger.logTraceContext),
-                logTraceContext -> logTraceContext.toString());
+        quarkusTracer.setLogTraceContext(jaeger.logTraceContext);
     }
 
     private <T> void initTracerProperty(String property, Optional<T> value, Function<T, String> accessor) {

extensions/jaeger/runtime/src/main/java/io/quarkus/jaeger/runtime/QuarkusJaegerMetricsFactory.java

@@ -21,6 +21,9 @@ public class QuarkusJaegerMetricsFactory implements MetricsFactory {
 
     @Override
     public Counter createCounter(final String name, final Map<String, String> tags) {
+        // On restart (e.g. in dev mode) Jaeger registers
+        // the same metrics which would result in exception
+        registry.remove(name);
         org.eclipse.microprofile.metrics.Counter counter = registry.counter(meta(name, MetricType.COUNTER), toTagArray(tags));
 
         return new Counter() {
@@ -33,6 +36,7 @@ public class QuarkusJaegerMetricsFactory implements MetricsFactory {
 
     @Override
     public Timer createTimer(final String name, final Map<String, String> tags) {
+        registry.remove(name);
         org.eclipse.microprofile.metrics.Timer timer = registry.timer(meta(name, MetricType.TIMER), toTagArray(tags));
 
         return new Timer() {
@@ -45,6 +49,7 @@ public class QuarkusJaegerMetricsFactory implements MetricsFactory {
 
     @Override
     public Gauge createGauge(final String name, final Map<String, String> tags) {
+        registry.remove(name);
         JaegerGauge gauge = registry.register(meta(name, MetricType.GAUGE), new JaegerGauge(), toTagArray(tags));
 
         return new Gauge() {

extensions/jaeger/runtime/src/main/java/io/quarkus/jaeger/runtime/QuarkusJaegerTracer.java

@@ -1,6 +1,7 @@
 package io.quarkus.jaeger.runtime;
 
 import io.jaegertracing.Configuration;
+import io.jaegertracing.internal.JaegerTracer;
 import io.opentracing.ScopeManager;
 import io.opentracing.Span;
 import io.opentracing.SpanContext;
@@ -10,17 +11,29 @@ import io.opentracing.util.ThreadLocalScopeManager;
 
 public class QuarkusJaegerTracer implements Tracer {
 
-    static final String LOG_TRACE_CONTEXT = "JAEGER_LOG_TRACE_CONTEXT";
-    private static volatile Tracer tracer;
+    private volatile JaegerTracer tracer;
+
+    private boolean logTraceContext;
+
+    void setLogTraceContext(boolean logTraceContext) {
+        this.logTraceContext = logTraceContext;
+    }
 
     @Override
     public String toString() {
         return tracer().toString();
     }
 
-    private static Tracer tracer() {
+    synchronized void reset() {
+        if (tracer != null) {
+            tracer.close();
+        }
+        tracer = null;
+    }
+
+    private Tracer tracer() {
         if (tracer == null) {
-            synchronized (QuarkusJaegerTracer.class) {
+            synchronized (this) {
                 if (tracer == null) {
                     tracer = Configuration.fromEnv()
                             .withMetricsFactory(new QuarkusJaegerMetricsFactory())
@@ -33,10 +46,9 @@ public class QuarkusJaegerTracer implements Tracer {
         return tracer;
     }
 
-    private static ScopeManager getScopeManager() {
+    private ScopeManager getScopeManager() {
         ScopeManager scopeManager = new ThreadLocalScopeManager();
-        String logTraceContext = System.getProperty(LOG_TRACE_CONTEXT);
-        if ("true".equals(logTraceContext)) {
+        if (logTraceContext) {
             scopeManager = new MDCScopeManager(scopeManager);
         }
         return scopeManager;

extensions/smallrye-opentracing/deployment/src/test/java/io/quarkus/smallrye/opentracing/deployment/TracerRegistrar.java

@@ -1,15 +0,0 @@
-package io.quarkus.smallrye.opentracing.deployment;
-
-import javax.enterprise.context.ApplicationScoped;
-import javax.enterprise.event.Observes;
-
-import io.opentracing.util.GlobalTracer;
-import io.quarkus.runtime.StartupEvent;
-
-@ApplicationScoped
-public class TracerRegistrar {
-
-    public void start(@Observes StartupEvent start) {
-        GlobalTracer.register(TracingTest.mockTracer);
-    }
-}

extensions/smallrye-opentracing/deployment/src/test/java/io/quarkus/smallrye/opentracing/deployment/TracingTest.java

@@ -15,6 +15,7 @@ import org.junit.jupiter.api.extension.RegisterExtension;
 
 import io.opentracing.mock.MockSpan;
 import io.opentracing.mock.MockTracer;
+import io.opentracing.util.GlobalTracer;
 import io.opentracing.util.GlobalTracerTestUtil;
 import io.quarkus.test.QuarkusUnitTest;
 import io.restassured.RestAssured;
@@ -27,12 +28,14 @@ public class TracingTest {
     static final QuarkusUnitTest config = new QuarkusUnitTest()
             .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
                     .addClass(TestResource.class)
-                    .addClass(TracerRegistrar.class)
                     .addClass(Service.class)
                     .addClass(RestService.class)
                     .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml"));
 
     static MockTracer mockTracer = new MockTracer();
+    static {
+        GlobalTracer.register(mockTracer);
+    }
 
     @AfterEach
     public void after() {