Closes #1297 - Add exporter services and their registration with OpenTelemetry

components/inspectit-ocelot-configurationserver/src/main/java/rocks/inspectit/ocelot/file/accessor/git/RevisionAccess.java

@@ -18,7 +18,10 @@
 import java.io.IOException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
 
 /**
  * Accessor to access specific Git revision/commits. Using this class ensures that all operations will be executed
@@ -110,7 +113,7 @@ public RevisionAccess getCommonAncestor(RevisionAccess other) {
             RevWalk walk = new RevWalk(repository);
             walk.setRevFilter(RevFilter.MERGE_BASE);
             // RevCommits need to be produced by the same RevWalk instance otherwise it can't compare them
-            walk.markStart(walk.parseCommit(this.revCommit.toObjectId()));
+            walk.markStart(walk.parseCommit(revCommit.toObjectId()));
             walk.markStart(walk.parseCommit(other.revCommit.toObjectId()));
             RevCommit mergeBase = walk.next();
 
@@ -186,7 +189,8 @@ protected String verifyPath(String relativeBasePath, String relativePath) throws
         Path path = Paths.get(relativePath).normalize();
 
         if (StringUtils.isBlank(relativeBasePath)) {
-            return path.toString().replace("\\", "/");
+            // replace '\' with '/'. A regex that matches a single backslash character must include four backslashes, see https://www.gnu.org/software/guile/manual/html_node/Backslash-Escapes.html
+            return path.toString().replaceAll("\\\\", "/");
         }
 
         Path basePath = Paths.get(relativeBasePath).normalize();
@@ -196,7 +200,8 @@ protected String verifyPath(String relativeBasePath, String relativePath) throws
             throw new IllegalArgumentException("User path escapes the base path: " + relativePath);
         }
 
-        return resolvedPath.toString().replace("\\", "/");
+        // replace '\' with '/'. A regex that matches a single backslash character must include four backslashes, see https://www.gnu.org/software/guile/manual/html_node/Backslash-Escapes.html
+        return resolvedPath.toString().replaceAll("\\\\", "/");
     }
 
     @Override

components/inspectit-ocelot-eum-server/src/main/java/rocks/inspectit/oce/eum/server/exporters/InfluxExporterService.java

@@ -46,10 +46,13 @@ public class InfluxExporterService {
     private boolean shouldEnable() {
         InfluxExporterSettings influx = configuration.getExporters().getMetrics().getInflux();
         if (!influx.getEnabled().isDisabled()) {
-            if (StringUtils.hasText(influx.getUrl())) {
+            if (StringUtils.hasText(influx.getEndpoint())) {
+                return true;
+            } else if (StringUtils.hasText(influx.getUrl())) {
+                log.warn("You are using the deprecated property 'url'. This property will be invalid in future releases of InspectIT Ocelot, please use `endpoint` instead.");
                 return true;
             } else if (influx.getEnabled().equals(ExporterEnabledState.ENABLED)) {
-                log.warn("InfluxDB Exporter is enabled but no url set.");
+                log.warn("InfluxDB Exporter is enabled but 'endpoint' is not set.");
             }
         }
         return false;
@@ -59,9 +62,10 @@ private boolean shouldEnable() {
     private void doEnable() {
         InfluxExporterSettings influx = configuration.getExporters().getMetrics().getInflux();
         if (shouldEnable()) {
-            log.info("Starting InfluxDB Exporter to '{}:{}' on '{}'", influx.getDatabase(), influx.getRetentionPolicy(), influx.getUrl());
+            String endpoint = StringUtils.hasText(influx.getEndpoint()) ? influx.getEndpoint() : influx.getUrl();
+            log.info("Starting InfluxDB Exporter to '{}:{}' on '{}'", influx.getDatabase(), influx.getRetentionPolicy(), endpoint);
             activeExporter = InfluxExporter.builder()
-                    .url(influx.getUrl())
+                    .url(endpoint)
                     .database(influx.getDatabase())
                     .retention(influx.getRetentionPolicy())
                     .user(influx.getUser())

components/inspectit-ocelot-eum-server/src/main/java/rocks/inspectit/oce/eum/server/exporters/configuration/TraceExportersConfiguration.java

@@ -17,6 +17,7 @@
 import rocks.inspectit.ocelot.config.model.exporters.trace.TraceExportersSettings;
 
 import javax.annotation.PostConstruct;
+import javax.validation.Valid;
 import java.util.Optional;
 
 @Configuration
@@ -33,23 +34,23 @@ public void logWrongJaegerConfig() {
                 .map(TraceExportersSettings::getJaeger)
                 .filter((jaeger) -> !jaeger.getEnabled().isDisabled())
                 .ifPresent(settings -> {
-                    if (StringUtils.hasText(settings.getUrl()) && !StringUtils.hasText(settings.getGrpc())) {
-                        log.warn("In order to use Jaeger span exporter, please specify the grpc API endpoint property instead of the url.");
+                    if (StringUtils.hasText(settings.getUrl()) && !StringUtils.hasText(settings.getEndpoint())) {
+                        log.warn("In order to use Jaeger span exporter, please specify the grpc API 'endpoint' property instead of the 'url'.");
                     }
                 });
     }
 
     @Bean(destroyMethod = "shutdown")
-    @ConditionalOnProperty({"inspectit-eum-server.exporters.tracing.jaeger.enabled", "inspectit-eum-server.exporters.tracing.jaeger.grpc"})
-    @ConditionalOnExpression("(NOT new String('${inspectit-eum-server.exporters.tracing.jaeger.enabled}').toUpperCase().equals(T(rocks.inspectit.ocelot.config.model.exporters.ExporterEnabledState).DISABLED.toString())) AND (new String('${inspectit-eum-server.exporters.tracing.jaeger.grpc}').length() > 0)")
+    @ConditionalOnProperty({"inspectit-eum-server.exporters.tracing.jaeger.enabled", "inspectit-eum-server.exporters.tracing.jaeger.endpoint"})
+    @ConditionalOnExpression("(NOT new String('${inspectit-eum-server.exporters.tracing.jaeger.enabled}').toUpperCase().equals(T(rocks.inspectit.ocelot.config.model.exporters.ExporterEnabledState).DISABLED.toString())) AND (new String('${inspectit-eum-server.exporters.tracing.jaeger.endpoint}').length() > 0)")
     public SpanExporter jaegerSpanExporter() {
-        JaegerExporterSettings jaegerExporterSettings = configuration.getExporters().getTracing().getJaeger();
+        @Valid JaegerExporterSettings jaegerExporterSettings = configuration.getExporters().getTracing().getJaeger();
 
-        ManagedChannel channel = ManagedChannelBuilder.forTarget(jaegerExporterSettings.getGrpc())
+        ManagedChannel channel = ManagedChannelBuilder.forTarget(jaegerExporterSettings.getEndpoint())
                 .usePlaintext()
                 .build();
 
-        log.info("Starting Jaeger Exporter on grpc '{}'", jaegerExporterSettings.getGrpc());
+        log.info("Starting Jaeger Exporter on grpc '{}'", jaegerExporterSettings.getEndpoint());
         System.setProperty("otel.resource.attributes", "service.name=" + jaegerExporterSettings.getServiceName());
 
         return JaegerGrpcSpanExporter.builder().setChannel(channel).build();

components/inspectit-ocelot-eum-server/src/main/resources/application.yml

@@ -172,10 +172,14 @@ inspectit-eum-server:
         # If jaeger exporter for the OT received spans is enabled.
         enabled: IF_CONFIGURED
 
+        # The transport protocol
+        protocol: grpc
+
         # Location of the jaeger gRPC API.
         # Either a valid NameResolver-compliant URI, or an authority string.
         # If this property is not set, the jaeger-exporter will not be started.
-        # grpc: localhost:14250
+        # endpoint: localhost:14250
+
 
         # service name for all exported spans.
         service-name: browser-js

components/inspectit-ocelot-eum-server/src/test/java/rocks/inspectit/oce/eum/server/exporters/JaegerExporterIntTest.java

@@ -16,6 +16,7 @@
 import org.testcontainers.containers.wait.strategy.Wait;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
+import rocks.inspectit.ocelot.config.model.exporters.ExporterEnabledState;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -41,16 +42,14 @@ public class JaegerExporterIntTest {
     public static final String SERVICE_NAME = "E2E-test";
 
     @Container
-    public static GenericContainer<?> jaegerContainer = new GenericContainer<>("ghcr.io/open-telemetry/java-test-containers:jaeger")
-            .withExposedPorts(COLLECTOR_PORT, QUERY_PORT, HEALTH_PORT)
+    public static GenericContainer<?> jaegerContainer = new GenericContainer<>("ghcr.io/open-telemetry/java-test-containers:jaeger").withExposedPorts(COLLECTOR_PORT, QUERY_PORT, HEALTH_PORT)
             .waitingFor(Wait.forHttp("/").forPort(HEALTH_PORT));
 
     static class EnvInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
 
         @Override
         public void initialize(ConfigurableApplicationContext applicationContext) {
-            TestPropertyValues.of(String.format("inspectit-eum-server.exporters.tracing.jaeger.grpc=%s:%d", jaegerContainer
-                    .getHost(), jaegerContainer.getMappedPort(COLLECTOR_PORT)), "inspectit-eum-server.exporters.tracing.jaeger.service-name=" + JaegerExporterIntTest.SERVICE_NAME)
+            TestPropertyValues.of("inspectit-eum-server.exporters.tracing.jaeger.enabled=" + ExporterEnabledState.ENABLED, String.format("inspectit-eum-server.exporters.tracing.jaeger.endpoint=%s:%d", jaegerContainer.getHost(), jaegerContainer.getMappedPort(COLLECTOR_PORT)), "inspectit-eum-server.exporters.tracing.jaeger.service-name=" + JaegerExporterIntTest.SERVICE_NAME, "inspectit-eum-server.exporters.tracing.jaeger.protocol=grpc")
                     .applyTo(applicationContext);
         }
     }

components/inspectit-ocelot-eum-server/src/test/java/rocks/inspectit/oce/eum/server/exporters/configuration/TraceExportersConfigurationTest.java

@@ -11,14 +11,14 @@
 
 /**
  * This Test class tests whether the annotations on {@link TraceExportersConfiguration#jaegerSpanExporter()} are working as expected,
- * i.e. whether the Bean only gets created when 'jaeger.enabled' is not set to DISABLED and 'jaeger.grpc' is not empty.
+ * i.e. whether the Bean only gets created when 'jaeger.enabled' is not set to DISABLED and 'jaeger.endpoint' is not empty.
  */
 @SpringBootTest
 class TraceExportersConfigurationTest {
 
-    @TestPropertySource(properties = {"inspectit-eum-server.exporters.tracing.jaeger.grpc=", "inspectit-eum-server.exporters.tracing.jaeger.enabled=ENABLED"})
+    @TestPropertySource(properties = {"inspectit-eum-server.exporters.tracing.jaeger.endpoint=", "inspectit-eum-server.exporters.tracing.jaeger.enabled=ENABLED"})
     @Nested
-    public class MissingGrpcTest {
+    public class MissingEndpointTest {
 
         @Autowired(required = false)
         JaegerGrpcSpanExporter exporter;
@@ -29,7 +29,7 @@ public void testBeanWasNotCreated() {
         }
     }
 
-    @TestPropertySource(properties = {"inspectit-eum-server.exporters.tracing.jaeger.grpc=localhost:1234", "inspectit-eum-server.exporters.tracing.jaeger.enabled=DISABLED"})
+    @TestPropertySource(properties = {"inspectit-eum-server.exporters.tracing.jaeger.endpoint=localhost:1234", "inspectit-eum-server.exporters.tracing.jaeger.enabled=DISABLED", "inspectit-eum-server.exporters.tracing.jaeger.protocol=grpc"})
     @Nested
     public class DisabledTest {
 
@@ -42,7 +42,7 @@ public void testBeanWasNotCreated() {
         }
     }
 
-    @TestPropertySource(properties = {"inspectit-eum-server.exporters.tracing.jaeger.grpc=localhost:1234", "inspectit-eum-server.exporters.tracing.jaeger.enabled=ENABLED"})
+    @TestPropertySource(properties = {"inspectit-eum-server.exporters.tracing.jaeger.endpoint=localhost:1234", "inspectit-eum-server.exporters.tracing.jaeger.enabled=ENABLED", "inspectit-eum-server.exporters.tracing.jaeger.protocol=grpc"})
     @Nested
     public class BothAvailableTest {
 

gradle.properties

@@ -8,9 +8,10 @@ logbackVersion=1.2.10
 # Ensure to adapt the netty version (inspectit-ocelot-core/build.gradle) when changing the OpenCensus version
 openCensusVersion=0.28.3
 # OpenTelemetry related
-openTelemetryVersion=1.9.1
-openTelemetryAlphaVersion=1.9.1-alpha
+openTelemetryVersion=1.10.0
+openTelemetryAlphaVersion=1.10.0-alpha
 
 prometheusClientVersion=0.6.0
 # appropriate netty version, see https://github.com/census-instrumentation/opencensus-java/blob/master/exporters/trace/ocagent/README.md
-tcnativeVersion=2.0.20.Final
+tcnativeVersion=2.0.20.Final
+grpcVersion=1.43.1

inspectit-ocelot-agent/build.gradle

@@ -128,6 +128,7 @@ dependencies {
             // for InMemorySpanExporter
             platform("io.opentelemetry:opentelemetry-bom:${openTelemetryVersion}"),
             "io.opentelemetry:opentelemetry-sdk-testing",
+            "io.opentelemetry:opentelemetry-exporter-logging",
             platform("io.opentelemetry:opentelemetry-bom-alpha:${openTelemetryAlphaVersion}"),
             "io.opentelemetry:opentelemetry-semconv",
 
@@ -243,7 +244,8 @@ task systemTest {
                 jvmArgs "-Dinspectit.config.file-based.path=$projectDir/src/system-test/resources/config"
                 // make inspectIT scan the workdir for configs
                 jvmArgs "-Dinspectit.publishOpenTelemetryToBootstrap=true"  // make inspectIT push OTEL to the bootstrap
-                jvmArgs jacoco.asJvmArg + ",inclbootstrapclasses=true"      // JaCoCo agent first + bootstrap instrumentation
+                jvmArgs jacoco.asJvmArg + ",inclbootstrapclasses=true"
+                // JaCoCo agent first + bootstrap instrumentation
                 jvmArgs "-javaagent:${agentJarPath}"  // Our agent second.
 
                 // stricter checker makes sure that {@link Scope}s are closed on the correct thread and
@@ -257,6 +259,11 @@ task systemTest {
                 }
 
                 jacoco.enabled = false  // Don't add the JaCoCo agent again.
+
+                // stricter checker makes sure that {@link Scope}s are closed on the correct thread and
+                // that they are not garbage collected before being closed.
+                jvmArgs "-Dio.opentelemetry.context.enableStrictContext=true"
+
             }
 
             doFirst { logger.lifecycle("Running system tests using ${javaExecutable}.") }

inspectit-ocelot-agent/src/main/java/rocks/inspectit/ocelot/agent/AgentMain.java

@@ -1,5 +1,7 @@
 package rocks.inspectit.ocelot.agent;
 
+import lombok.AllArgsConstructor;
+import lombok.Value;
 import rocks.inspectit.ocelot.bootstrap.AgentManager;
 import rocks.inspectit.ocelot.bootstrap.Instances;
 

inspectit-ocelot-agent/src/system-test/java/rocks/inspectit/ocelot/instrumentation/special/logging/Log4J2TraceIdAutoInjectorTest.java

@@ -8,6 +8,7 @@
 import org.apache.logging.log4j.message.MessageFactory;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
+import rocks.inspectit.ocelot.bootstrap.Instances;
 import rocks.inspectit.ocelot.instrumentation.InstrumentationSysTestBase;
 import rocks.inspectit.ocelot.logging.Log4J2LoggingRecorder;
 import rocks.inspectit.ocelot.utils.TestUtils;
@@ -32,6 +33,8 @@ public static void initializeOpenTelemetry() {
 
     @Test
     public void logStringAndTraceExists() {
+        System.out.println(String.format("OTEL=%s, tracer=%s", Instances.openTelemetryController.getClass()
+                .getSimpleName(), Tracing.getTracer().getClass().getSimpleName()));
         Log4J2LoggingRecorder.loggingEvents.clear();
         String message = "This is a traced String in {}.";
         String traceId;

inspectit-ocelot-agent/src/system-test/java/rocks/inspectit/ocelot/instrumentation/tracing/TraceTestBase.java

@@ -38,15 +38,14 @@ void destroyExporter() {
     void assertTraceExported(Consumer<? super List<? extends SpanData>> assertions) {
 
         await().atMost(15, TimeUnit.SECONDS).untilAsserted(() -> {
-            Map<String, List<SpanData>> traces = getExportedSpans().stream()
+            Map<String, List<io.opentelemetry.sdk.trace.data.SpanData>> traces = getExportedSpans().stream()
                     .collect(Collectors.groupingBy(s -> s.getSpanContext().getTraceId(), Collectors.toList()));
             assertThat(traces.values()).anySatisfy(assertions);
             assertThat(traces.values()).filteredOnAssertions(assertions).hasSize(1);
         });
     }
 
-    void assertSpansExported(Consumer<? super Collection<? extends SpanData>> assertions) {
-
+    void assertSpansExported(Consumer<? super Collection<? extends io.opentelemetry.sdk.trace.data.SpanData>> assertions) {
         await().atMost(15, TimeUnit.SECONDS).untilAsserted(() -> {
             assertions.accept(getExportedSpans());
         });

inspectit-ocelot-agent/src/system-test/java/rocks/inspectit/ocelot/utils/TestUtils.java

@@ -14,21 +14,20 @@
 import io.opentelemetry.api.GlobalOpenTelemetry;
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.Tracer;
-import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
-import io.opentelemetry.context.propagation.ContextPropagators;
-import io.opentelemetry.context.propagation.TextMapPropagator;
-import io.opentelemetry.extension.trace.propagation.B3Propagator;
 import io.opentelemetry.sdk.OpenTelemetrySdk;
 import io.opentelemetry.sdk.resources.Resource;
 import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter;
 import io.opentelemetry.sdk.trace.SdkTracerProvider;
 import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;
 import io.opentelemetry.sdk.trace.samplers.Sampler;
 import io.opentelemetry.semconv.resource.attributes.ResourceAttributes;
+import org.awaitility.Awaitility;
 import org.awaitility.core.ConditionTimeoutException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import rocks.inspectit.ocelot.bootstrap.AgentManager;
+import rocks.inspectit.ocelot.bootstrap.Instances;
+import rocks.inspectit.ocelot.bootstrap.opentelemetry.NoopOpenTelemetryController;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
@@ -233,6 +232,17 @@ public static void waitForInstrumentationToComplete() {
         });
     }
 
+    /**
+     * Waits for the initialization of {@link rocks.inspectit.ocelot.core.opentelemetry.OpenTelemetryControllerImpl}, which is then registered to {@link Instances#openTelemetryController}
+     */
+    public static void waitForOpenTelemetryControllerInitialization() {
+        Awaitility.await().atMost(30, TimeUnit.SECONDS).untilAsserted(() -> {
+            assertThat(NoopOpenTelemetryController.INSTANCE != Instances.openTelemetryController).isTrue();
+            assertThat(Instances.openTelemetryController.isEnabled()).isTrue();
+            assertThat(Instances.openTelemetryController.isConfigured()).isTrue();
+        });
+    }
+
     public static Map<String, String> getCurrentTagsAsMap() {
         Map<String, String> result = new HashMap<>();
         InternalUtils.getTags(Tags.getTagger().getCurrentTagContext())
@@ -313,6 +323,13 @@ public static TimeSeries getTimeseries(String metricName, Map<String, String> ta
      */
     public static InMemorySpanExporter initializeOpenTelemetryForSystemTesting() {
 
+        if (NoopOpenTelemetryController.INSTANCE != Instances.openTelemetryController) {
+            logger.info("shut down " + Instances.openTelemetryController.getClass().getSimpleName());
+
+            // shut down any previously configured OTELs
+            Instances.openTelemetryController.shutdown();
+            Instances.openTelemetryController = NoopOpenTelemetryController.INSTANCE;
+        }
         // create an SdkTracerProvider with InMemorySpanExporter and LoggingSpanExporter
         InMemorySpanExporter inMemSpanExporter = InMemorySpanExporter.create();
 
@@ -341,8 +358,7 @@ public static InMemorySpanExporter initializeOpenTelemetryForSystemTesting() {
             modifiers.setInt(tracerField, tracerField.getModifiers() & ~Modifier.FINAL);
             tracerField.set(null, tracer);
 
-            logger.info("OTEL_TRACER updated to {} ({})",
-                    tracer, openTelemetry.getTracer("io.opentelemetry.opencensusshim"));
+            logger.info("OTEL_TRACER updated to {} ({})", tracer, openTelemetry.getTracer("io.opentelemetry.opencensusshim"));
         } catch (Exception e) {
             logger.error("Failed to set OTEL_TRACER in OpenTelemetrySpanBuilderImpl", e);
         }

inspectit-ocelot-bootstrap/src/main/java/rocks/inspectit/ocelot/bootstrap/Instances.java

@@ -10,6 +10,8 @@
 import rocks.inspectit.ocelot.bootstrap.instrumentation.IHookManager;
 import rocks.inspectit.ocelot.bootstrap.instrumentation.noop.NoopHookManager;
 import rocks.inspectit.ocelot.bootstrap.instrumentation.noop.NoopObjectAttachments;
+import rocks.inspectit.ocelot.bootstrap.opentelemetry.IOpenTelemetryController;
+import rocks.inspectit.ocelot.bootstrap.opentelemetry.NoopOpenTelemetryController;
 
 import java.net.URL;
 
@@ -41,4 +43,6 @@ public class Instances {
     public static LogTraceCorrelator logTraceCorrelator = NoopLogTraceCorrelator.INSTANCE;
 
     public static TraceIdInjector traceIdInjector = NoopTraceIdInjector.INSTANCE;
+
+    public static IOpenTelemetryController openTelemetryController = NoopOpenTelemetryController.INSTANCE;
 }