Add OTel Metrics plus refactor for generic senders

extensions/opentelemetry/deployment/src/main/java/io/quarkus/opentelemetry/deployment/OpenTelemetryProcessor.java

@@ -105,6 +105,7 @@ AdditionalBeanBuildItem ensureProducerIsRetained() {
                         AutoConfiguredOpenTelemetrySdkBuilderCustomizer.ResourceCustomizer.class,
                         AutoConfiguredOpenTelemetrySdkBuilderCustomizer.SamplerCustomizer.class,
                         AutoConfiguredOpenTelemetrySdkBuilderCustomizer.TracerProviderCustomizer.class,
+                        AutoConfiguredOpenTelemetrySdkBuilderCustomizer.MetricProviderCustomizer.class,
                         AutoConfiguredOpenTelemetrySdkBuilderCustomizer.TextMapPropagatorCustomizers.class)
                 .build();
     }

extensions/opentelemetry/deployment/src/main/java/io/quarkus/opentelemetry/deployment/exporter/otlp/OtlpExporterProcessor.java

@@ -13,6 +13,7 @@
 import org.jboss.jandex.ParameterizedType;
 import org.jboss.jandex.Type;
 
+import io.opentelemetry.sdk.metrics.export.MetricExporter;
 import io.opentelemetry.sdk.trace.SpanProcessor;
 import io.opentelemetry.sdk.trace.export.SpanExporter;
 import io.quarkus.arc.deployment.AdditionalBeanBuildItem;
@@ -26,16 +27,16 @@
 import io.quarkus.opentelemetry.runtime.config.build.exporter.OtlpExporterBuildConfig;
 import io.quarkus.opentelemetry.runtime.config.runtime.OTelRuntimeConfig;
 import io.quarkus.opentelemetry.runtime.config.runtime.exporter.OtlpExporterRuntimeConfig;
-import io.quarkus.opentelemetry.runtime.exporter.otlp.EndUserSpanProcessor;
-import io.quarkus.opentelemetry.runtime.exporter.otlp.LateBoundBatchSpanProcessor;
 import io.quarkus.opentelemetry.runtime.exporter.otlp.OTelExporterRecorder;
+import io.quarkus.opentelemetry.runtime.exporter.otlp.tracing.EndUserSpanProcessor;
+import io.quarkus.opentelemetry.runtime.exporter.otlp.tracing.LateBoundBatchSpanProcessor;
 import io.quarkus.runtime.TlsConfig;
 import io.quarkus.vertx.core.deployment.CoreVertxBuildItem;
 
-@BuildSteps(onlyIf = OtlpExporterProcessor.OtlpExporterEnabled.class)
+@BuildSteps
 public class OtlpExporterProcessor {
 
-    static class OtlpExporterEnabled implements BooleanSupplier {
+    static class OtlpTracingExporterEnabled implements BooleanSupplier {
         OtlpExporterBuildConfig exportBuildConfig;
         OTelBuildConfig otelBuildConfig;
 
@@ -47,7 +48,19 @@ public boolean getAsBoolean() {
         }
     }
 
-    @BuildStep
+    static class OtlpMetricsExporterEnabled implements BooleanSupplier {
+        OtlpExporterBuildConfig exportBuildConfig;
+        OTelBuildConfig otelBuildConfig;
+
+        public boolean getAsBoolean() {
+            return otelBuildConfig.enabled() &&
+                    otelBuildConfig.metrics().enabled().orElse(Boolean.TRUE) &&
+                    otelBuildConfig.metrics().exporter().contains(CDI_VALUE) &&
+                    exportBuildConfig.enabled();
+        }
+    }
+
+    @BuildStep(onlyIf = OtlpExporterProcessor.OtlpTracingExporterEnabled.class)
     void createEndUserSpanProcessor(
             BuildProducer<AdditionalBeanBuildItem> buildProducer,
             OTelBuildConfig otelBuildConfig) {
@@ -59,7 +72,7 @@ void createEndUserSpanProcessor(
     }
 
     @SuppressWarnings("deprecation")
-    @BuildStep
+    @BuildStep(onlyIf = OtlpExporterProcessor.OtlpTracingExporterEnabled.class)
     @Record(ExecutionTime.RUNTIME_INIT)
     void createBatchSpanProcessor(OTelExporterRecorder recorder,
             OTelRuntimeConfig otelRuntimeConfig,
@@ -84,4 +97,32 @@ void createBatchSpanProcessor(OTelExporterRecorder recorder,
                         vertxBuildItem.getVertx()))
                 .done());
     }
+
+    @BuildStep(onlyIf = OtlpMetricsExporterEnabled.class)
+    @Record(ExecutionTime.RUNTIME_INIT)
+    void createMetricsExporterProcessor(
+            OTelExporterRecorder recorder,
+            List<ExternalOtelExporterBuildItem> externalOtelExporterBuildItem,
+            OTelRuntimeConfig otelRuntimeConfig,
+            OtlpExporterRuntimeConfig exporterRuntimeConfig,
+            TlsConfig tlsConfig,
+            CoreVertxBuildItem vertxBuildItem,
+            BuildProducer<SyntheticBeanBuildItem> syntheticBeanBuildItemBuildProducer) {
+        if (!externalOtelExporterBuildItem.isEmpty()) {
+            // if there is an external exporter, we don't want to create the default one
+            return;
+        }
+
+        syntheticBeanBuildItemBuildProducer.produce(SyntheticBeanBuildItem
+                .configure(MetricExporter.class)// FIXME concrete class? No, PeriodicMetricReader is final
+                .types(MetricExporter.class)
+                .setRuntimeInit()
+                .scope(Singleton.class)
+                .unremovable()
+                .addInjectionPoint(ParameterizedType.create(DotName.createSimple(Instance.class),
+                        new Type[] { ClassType.create(DotName.createSimple(MetricExporter.class.getName())) }, null))
+                .createWith(recorder.createMetricExporter(otelRuntimeConfig, exporterRuntimeConfig, tlsConfig,
+                        vertxBuildItem.getVertx()))
+                .done());
+    }
 }

extensions/opentelemetry/deployment/src/main/java/io/quarkus/opentelemetry/deployment/metric/MetricProcessor.java

@@ -0,0 +1,96 @@
+package io.quarkus.opentelemetry.deployment.metric;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.function.BooleanSupplier;
+import java.util.function.Function;
+
+import org.jboss.jandex.AnnotationInstance;
+import org.jboss.jandex.AnnotationTarget;
+import org.jboss.jandex.DotName;
+import org.jboss.jandex.FieldInfo;
+import org.jboss.jandex.IndexView;
+import org.jboss.jandex.MethodInfo;
+
+import io.opentelemetry.sdk.metrics.export.MetricExporter;
+import io.opentelemetry.sdk.metrics.export.MetricReader;
+import io.quarkus.arc.deployment.AdditionalBeanBuildItem;
+import io.quarkus.arc.deployment.UnremovableBeanBuildItem;
+import io.quarkus.arc.processor.DotNames;
+import io.quarkus.deployment.annotations.BuildProducer;
+import io.quarkus.deployment.annotations.BuildStep;
+import io.quarkus.deployment.annotations.BuildSteps;
+import io.quarkus.deployment.builditem.CombinedIndexBuildItem;
+import io.quarkus.opentelemetry.runtime.config.build.OTelBuildConfig;
+import io.quarkus.opentelemetry.runtime.metrics.cdi.MetricsProducer;
+
+@BuildSteps(onlyIf = MetricProcessor.MetricEnabled.class)
+public class MetricProcessor {
+    private static final DotName METRIC_EXPORTER = DotName.createSimple(MetricExporter.class.getName());
+    private static final DotName METRIC_READER = DotName.createSimple(MetricReader.class.getName());
+
+    @BuildStep
+    UnremovableBeanBuildItem ensureProducersAreRetained(
+            CombinedIndexBuildItem indexBuildItem,
+            BuildProducer<AdditionalBeanBuildItem> additionalBeans) {
+
+        additionalBeans.produce(AdditionalBeanBuildItem.builder()
+                .setUnremovable()
+                .addBeanClass(MetricsProducer.class)
+                .build());
+
+        IndexView index = indexBuildItem.getIndex();
+
+        // Find all known SpanExporters and SpanProcessors
+        Collection<String> knownClasses = new HashSet<>();
+        knownClasses.add(METRIC_EXPORTER.toString());
+        index.getAllKnownImplementors(METRIC_EXPORTER)
+                .forEach(classInfo -> knownClasses.add(classInfo.name().toString()));
+
+        knownClasses.add(METRIC_READER.toString());
+        index.getAllKnownImplementors(METRIC_READER)
+                .forEach(classInfo -> knownClasses.add(classInfo.name().toString()));
+
+        Set<String> retainProducers = new HashSet<>();
+
+        for (AnnotationInstance annotation : index.getAnnotations(DotNames.PRODUCES)) {
+            AnnotationTarget target = annotation.target();
+            switch (target.kind()) {
+                case METHOD:
+                    MethodInfo method = target.asMethod();
+                    String returnType = method.returnType().name().toString();
+                    if (knownClasses.contains(returnType)) {
+                        retainProducers.add(method.declaringClass().name().toString());
+                    }
+                    break;
+                case FIELD:
+                    FieldInfo field = target.asField();
+                    String fieldType = field.type().name().toString();
+                    if (knownClasses.contains(fieldType)) {
+                        retainProducers.add(field.declaringClass().name().toString());
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        return new UnremovableBeanBuildItem(new UnremovableBeanBuildItem.BeanClassNamesExclusion(retainProducers));
+    }
+
+    public static class MetricEnabled implements BooleanSupplier {
+        OTelBuildConfig otelBuildConfig;
+
+        public boolean getAsBoolean() {
+            return otelBuildConfig.metrics().enabled()
+                    .map(new Function<Boolean, Boolean>() {
+                        @Override
+                        public Boolean apply(Boolean enabled) {
+                            return otelBuildConfig.enabled() && enabled;
+                        }
+                    })
+                    .orElseGet(() -> otelBuildConfig.enabled());
+        }
+    }
+}

extensions/opentelemetry/deployment/src/main/java/io/quarkus/opentelemetry/deployment/tracing/TracerEnabled.java

@@ -9,12 +9,13 @@ public class TracerEnabled implements BooleanSupplier {
     OTelBuildConfig otelConfig;
 
     public boolean getAsBoolean() {
-        return otelConfig.traces().enabled().map(new Function<Boolean, Boolean>() {
-            @Override
-            public Boolean apply(Boolean tracerEnabled) {
-                return otelConfig.enabled() && tracerEnabled;
-            }
-        })
+        return otelConfig.traces().enabled()
+                .map(new Function<Boolean, Boolean>() {
+                    @Override
+                    public Boolean apply(Boolean tracerEnabled) {
+                        return otelConfig.enabled() && tracerEnabled;
+                    }
+                })
                 .orElseGet(() -> otelConfig.enabled());
     }
 }

extensions/opentelemetry/deployment/src/test/java/io/quarkus/opentelemetry/deployment/OpenTelemetryContinuousTestingTest.java

@@ -10,6 +10,7 @@
 import io.quarkus.opentelemetry.deployment.common.TestSpanExporter;
 import io.quarkus.opentelemetry.deployment.common.TestSpanExporterProvider;
 import io.quarkus.opentelemetry.deployment.common.TracerRouter;
+import io.quarkus.opentelemetry.deployment.traces.TracerRouterUT;
 import io.quarkus.test.ContinuousTestingTestUtils;
 import io.quarkus.test.ContinuousTestingTestUtils.TestStatus;
 import io.quarkus.test.QuarkusDevModeTest;
@@ -23,7 +24,8 @@ public class OpenTelemetryContinuousTestingTest {
                     .addAsResource(new StringAsset(TestSpanExporterProvider.class.getCanonicalName()),
                             "META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSpanExporterProvider")
                     .add(new StringAsset(ContinuousTestingTestUtils.appProperties(
-                            "quarkus.otel.traces.exporter=test-span-exporter")),
+                            "quarkus.otel.traces.exporter=test-span-exporter",
+                            "quarkus.otel.metrics.exporter=none")),
                             "application.properties"))
             .setTestArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
                     .addClass(TracerRouterUT.class));

extensions/opentelemetry/deployment/src/test/java/io/quarkus/opentelemetry/deployment/OpenTelemetryDestroyerTest.java

@@ -26,8 +26,11 @@ public class OpenTelemetryDestroyerTest {
                     .addAsResource(new StringAsset(TestSpanExporterProvider.class.getCanonicalName()),
                             "META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSpanExporterProvider")
                     .add(new StringAsset(
-                            "quarkus.otel.traces.exporter=test-span-exporter\n" +
-                                    "quarkus.otel.experimental.shutdown-wait-time=PT60S\n"),
+                            """
+                                    quarkus.otel.traces.exporter=test-span-exporter
+                                    quarkus.otel.metrics.exporter=none
+                                    quarkus.otel.experimental.shutdown-wait-time=PT60S
+                                    """),
                             "application.properties"));
 
     @Test

extensions/opentelemetry/deployment/src/test/java/io/quarkus/opentelemetry/deployment/OpenTelemetryDevModeTest.java

@@ -23,7 +23,8 @@ public class OpenTelemetryDevModeTest {
                     .addAsResource(new StringAsset(TestSpanExporterProvider.class.getCanonicalName()),
                             "META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSpanExporterProvider")
                     .add(new StringAsset(ContinuousTestingTestUtils.appProperties(
-                            "quarkus.otel.traces.exporter=test-span-exporter")), "application.properties"));
+                            "quarkus.otel.traces.exporter=test-span-exporter",
+                            "quarkus.otel.metrics.exporter=none")), "application.properties"));
 
     @Test
     void testDevMode() {

extensions/opentelemetry/deployment/src/test/java/io/quarkus/opentelemetry/deployment/OpenTelemetryDevServicesDatasourcesTest.java

@@ -41,11 +41,14 @@ public class OpenTelemetryDevServicesDatasourcesTest {
                     .addAsResource(new StringAsset(TestSpanExporterProvider.class.getCanonicalName()),
                             "META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSpanExporterProvider")
                     .add(new StringAsset(
-                            "quarkus.datasource.db-kind=h2\n" +
-                                    "quarkus.datasource.jdbc.telemetry=true\n" +
-                                    "quarkus.otel.traces.exporter=test-span-exporter\n" +
-                                    "quarkus.otel.bsp.export.timeout=1s\n" +
-                                    "quarkus.otel.bsp.schedule.delay=50\n"),
+                            """
+                                    quarkus.datasource.db-kind=h2
+                                    quarkus.datasource.jdbc.telemetry=true
+                                    quarkus.otel.traces.exporter=test-span-exporter
+                                    quarkus.otel.metrics.exporter=none
+                                    quarkus.otel.bsp.export.timeout=1s
+                                    quarkus.otel.bsp.schedule.delay=50
+                                    """),
                             "application.properties"));
 
     @Test

extensions/opentelemetry/deployment/src/test/java/io/quarkus/opentelemetry/deployment/OpenTelemetryDisabledSdkTest.java

@@ -8,7 +8,7 @@
 import org.junit.jupiter.api.extension.RegisterExtension;
 
 import io.opentelemetry.api.OpenTelemetry;
-import io.quarkus.opentelemetry.runtime.exporter.otlp.LateBoundBatchSpanProcessor;
+import io.quarkus.opentelemetry.runtime.exporter.otlp.tracing.LateBoundBatchSpanProcessor;
 import io.quarkus.test.QuarkusUnitTest;
 
 @Disabled("Not implemented")

extensions/opentelemetry/deployment/src/test/java/io/quarkus/opentelemetry/deployment/OpenTelemetryLegacyConfigurationTest.java

@@ -31,7 +31,6 @@ class OpenTelemetryLegacyConfigurationTest {
             .overrideConfigKey("quarkus.opentelemetry.tracer.sampler", "off")
             .overrideConfigKey("quarkus.opentelemetry.tracer.sampler.ratio", "2.0d")
             .overrideConfigKey("quarkus.opentelemetry.tracer.exporter.otlp.headers", "header=value")
-            .overrideConfigKey("quarkus.opentelemetry.tracer.exporter.otlp.enabled", "false")
             .overrideConfigKey("quarkus.opentelemetry.tracer.exporter.otlp.endpoint", "http://localhost:4318/");
 
     @Inject
@@ -58,7 +57,6 @@ void config() {
         assertEquals("always_off", oTelBuildConfig.traces().sampler());
         assertTrue(oTelRuntimeConfig.traces().samplerArg().isPresent());
         assertEquals("2.0d", oTelRuntimeConfig.traces().samplerArg().get());
-        assertEquals(FALSE, otlpExporterBuildConfig.enabled());
         assertTrue(otlpExporterRuntimeConfig.traces().legacyEndpoint().isPresent());
         assertTrue(otlpExporterRuntimeConfig.traces().headers().isPresent());
         assertEquals("header=value", otlpExporterRuntimeConfig.traces().headers().get().get(0));

extensions/opentelemetry/deployment/src/test/java/io/quarkus/opentelemetry/deployment/OpenTelemetryMDCTest.java

@@ -28,6 +28,8 @@
 import io.opentelemetry.context.Scope;
 import io.opentelemetry.sdk.trace.data.SpanData;
 import io.quarkus.arc.Unremovable;
+import io.quarkus.opentelemetry.deployment.common.InMemoryMetricExporter;
+import io.quarkus.opentelemetry.deployment.common.InMemoryMetricExporterProvider;
 import io.quarkus.opentelemetry.deployment.common.TestSpanExporter;
 import io.quarkus.opentelemetry.deployment.common.TestSpanExporterProvider;
 import io.quarkus.test.QuarkusUnitTest;
@@ -40,9 +42,12 @@ public class OpenTelemetryMDCTest {
                     .addClass(MdcEntry.class)
                     .addClass(TestMdcCapturer.class)
                     .addClass(TestResource.class)
-                    .addClasses(TestSpanExporter.class, TestSpanExporterProvider.class)
+                    .addClasses(TestSpanExporter.class, TestSpanExporterProvider.class,
+                            InMemoryMetricExporter.class, InMemoryMetricExporterProvider.class)
                     .addAsResource(new StringAsset(TestSpanExporterProvider.class.getCanonicalName()),
-                            "META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSpanExporterProvider"))
+                            "META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSpanExporterProvider")
+                    .addAsResource(new StringAsset(InMemoryMetricExporterProvider.class.getCanonicalName()),
+                            "META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.metrics.ConfigurableMetricExporterProvider"))
             .withConfigurationResource("application-default.properties");
 
     @Inject

extensions/opentelemetry/deployment/src/test/java/io/quarkus/opentelemetry/deployment/OpenTelemetryResourceTest.java

@@ -13,12 +13,17 @@
 import jakarta.ws.rs.Path;
 
 import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.StringAsset;
 import org.jboss.shrinkwrap.api.spec.JavaArchive;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
 import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.sdk.metrics.data.MetricData;
 import io.opentelemetry.sdk.trace.data.SpanData;
+import io.quarkus.opentelemetry.deployment.common.InMemoryMetricExporter;
+import io.quarkus.opentelemetry.deployment.common.InMemoryMetricExporterProvider;
 import io.quarkus.opentelemetry.deployment.common.TestSpanExporter;
 import io.quarkus.opentelemetry.deployment.common.TestSpanExporterProvider;
 import io.quarkus.test.QuarkusUnitTest;
@@ -29,17 +34,21 @@ public class OpenTelemetryResourceTest {
     @RegisterExtension
     static final QuarkusUnitTest TEST = new QuarkusUnitTest().setArchiveProducer(
             () -> ShrinkWrap.create(JavaArchive.class)
-                    .addClass(TestSpanExporter.class)
-                    .addClass(TestSpanExporterProvider.class)
+                    .addClasses(TestSpanExporter.class, TestSpanExporterProvider.class,
+                            InMemoryMetricExporter.class, InMemoryMetricExporterProvider.class)
                     .addAsResource("resource-config/application.properties", "application.properties")
                     .addAsResource(
                             "META-INF/services-config/io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSpanExporterProvider",
-                            "META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSpanExporterProvider"));
+                            "META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSpanExporterProvider")
+                    .addAsResource(new StringAsset(InMemoryMetricExporterProvider.class.getCanonicalName()),
+                            "META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.metrics.ConfigurableMetricExporterProvider"));
 
     @Inject
     SmallRyeConfig config;
     @Inject
     TestSpanExporter spanExporter;
+    @Inject
+    InMemoryMetricExporter metricExporter;
 
     @Test
     void resource() {
@@ -56,12 +65,19 @@ void resource() {
         assertEquals(config.getRawValue("quarkus.uuid"),
                 server.getResource().getAttribute(AttributeKey.stringKey("service.instance.id")));
         assertNotNull(server.getResource().getAttribute(AttributeKey.stringKey("host.name")));
+
+        metricExporter.assertCountAtLeast(1);
+        List<MetricData> finishedMetricItems = metricExporter.getFinishedMetricItems();
     }
 
     @Path("/hello")
     public static class HelloResource {
+        @Inject
+        Meter meter;
+
         @GET
         public String hello() {
+            meter.counterBuilder("hello").build().add(1);
             return "hello";
         }
     }