Ability to use 64 bit trace IDs (#1432)

Co-authored-by: Marius Brill <marius.brill@novatec-gmbh.de>

Author: mariusoe

inspectit-ocelot-config/src/main/java/rocks/inspectit/ocelot/config/model/tracing/TracingSettings.java

@@ -71,4 +71,9 @@ public enum AddCommonTags {
      */
     @Positive
     private long scheduleDelayMillis = 5000;
+
+    /**
+     * I enabled 64 Bit Trace Ids are used instead of the default 128 Bit.
+     */
+    private boolean use64BitTraceIds = false;
 }

inspectit-ocelot-config/src/main/resources/rocks/inspectit/ocelot/config/default/basics.yml

@@ -38,6 +38,8 @@ inspectit:
     auto-tracing:
       frequency: 50ms
       shutdown-delay: 30s
+    # whether the agent should use 64 bit trace ids instead of 128 bit trace ids
+    use-64-bit-trace-ids: false
     # settings regarding log correlation
     log-correlation:
       trace-id-mdc-injection:

inspectit-ocelot-core/src/main/java/rocks/inspectit/ocelot/core/instrumentation/context/ContextPropagationUtil.java

@@ -4,11 +4,11 @@
 import io.opencensus.trace.SpanContext;
 import io.opencensus.trace.Tracing;
 import io.opencensus.trace.propagation.TextFormat;
-import io.opentelemetry.api.baggage.propagation.W3CBaggagePropagator;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.util.CollectionUtils;
 import rocks.inspectit.ocelot.config.model.tracing.PropagationFormat;
 import rocks.inspectit.ocelot.core.instrumentation.context.propagation.DatadogFormat;
+import rocks.inspectit.ocelot.core.opentelemetry.trace.CustomIdGenerator;
 
 import java.net.URLDecoder;
 import java.net.URLEncoder;
@@ -118,12 +118,26 @@ public static Map<String, String> buildPropagationHeaderMap(Stream<Map.Entry<Str
     public static Map<String, String> buildPropagationHeaderMap(Stream<Map.Entry<String, Object>> dataToPropagate, SpanContext spanToPropagate) {
         String contextCorrelationData = buildCorrelationContextHeader(dataToPropagate);
         HashMap<String, String> result = new HashMap<>();
-        if (contextCorrelationData.length() > 0) {
-            result.put(CORRELATION_CONTEXT_HEADER, contextCorrelationData);
-        }
         if (spanToPropagate != null) {
             propagationFormat.inject(spanToPropagate, result, MAP_INJECTOR);
+
+            if (CustomIdGenerator.isUsing64Bit()) {
+                String traceid = spanToPropagate.getTraceId().toLowerBase16();
+                // do nothing in case trace ID is already 64bit
+                if (traceid.length() > 16) {
+                    for (Map.Entry<String, String> entry : result.entrySet()) {
+                        // we only trim the value in case it contains only the trace id (which is not the case when using the w3c trace context format)
+                        if (entry.getValue().equals(traceid)) {
+                            entry.setValue(traceid.substring(16));
+                        }
+                    }
+                }
+            }
         }
+        if (contextCorrelationData.length() > 0) {
+            result.put(CORRELATION_CONTEXT_HEADER, contextCorrelationData);
+        }
+
         return result;
     }
 
@@ -320,7 +334,7 @@ public static void setPropagationFormat(PropagationFormat format) {
                 log.info("Using Datadog format for context propagation.");
                 propagationFormat = DatadogFormat.INSTANCE;
                 break;
-             default:
+            default:
                 log.warn("The specified propagation format {} is not supported. Falling back to B3 format.", format);
                 propagationFormat = Tracing.getPropagationComponent().getB3Format();
         }

inspectit-ocelot-core/src/main/java/rocks/inspectit/ocelot/core/opentelemetry/OpenTelemetryControllerImpl.java

@@ -29,6 +29,7 @@
 import rocks.inspectit.ocelot.core.config.InspectitConfigChangedEvent;
 import rocks.inspectit.ocelot.core.config.InspectitEnvironment;
 import rocks.inspectit.ocelot.core.exporter.DynamicallyActivatableMetricsExporterService;
+import rocks.inspectit.ocelot.core.opentelemetry.trace.CustomIdGenerator;
 import rocks.inspectit.ocelot.core.utils.OpenCensusShimUtils;
 import rocks.inspectit.ocelot.core.utils.OpenTelemetryUtils;
 
@@ -118,8 +119,13 @@ public class OpenTelemetryControllerImpl implements IOpenTelemetryController {
     private SdkTracerProvider tracerProvider;
 
     @Autowired
+    @VisibleForTesting
     InspectitEnvironment env;
 
+    @Autowired
+    @VisibleForTesting
+    CustomIdGenerator idGenerator;
+
     /**
      * The {@link DynamicSampler} used for tracing
      */
@@ -310,7 +316,8 @@ void initOtel(InspectitConfig configuration) {
         // if any OpenTelemetry has already been registered to GlobalOpenTelemetry, reset it.
         if (null != OpenTelemetryUtils.getGlobalOpenTelemetry()) {
             // we need to reset it before we can register our custom OpenTelemetryImpl, as GlobalOpenTelemetry is throwing an exception if we want to register a new OpenTelemetry if a previous one is still registered.
-            log.info("Reset previously registered GlobalOpenTelemetry ({}) during the initialization of {} to register {}", GlobalOpenTelemetry.get()
+            log.info("Reset previously registered GlobalOpenTelemetry ({}) during the initialization of {} to register {}", GlobalOpenTelemetry
+                    .get()
                     .getClass()
                     .getName(), getName(), openTelemetry.getClass().getSimpleName());
             GlobalOpenTelemetry.resetForTest();
@@ -339,7 +346,9 @@ private SdkTracerProvider buildTracerProvider(InspectitConfig configuration) {
         SdkTracerProviderBuilder builder = SdkTracerProvider.builder()
                 .setSampler(sampler)
                 .setResource(serviceNameResource)
-                .addSpanProcessor(spanProcessor);
+                .addSpanProcessor(spanProcessor)
+                .setIdGenerator(idGenerator);
+
         return builder.build();
     }
 

inspectit-ocelot-core/src/main/java/rocks/inspectit/ocelot/core/opentelemetry/trace/CustomIdGenerator.java

@@ -0,0 +1,108 @@
+package rocks.inspectit.ocelot.core.opentelemetry.trace;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.opentelemetry.api.trace.SpanId;
+import io.opentelemetry.api.trace.TraceId;
+import io.opentelemetry.sdk.internal.RandomSupplier;
+import io.opentelemetry.sdk.trace.IdGenerator;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+import rocks.inspectit.ocelot.core.config.InspectitConfigChangedEvent;
+import rocks.inspectit.ocelot.core.config.InspectitEnvironment;
+
+import javax.annotation.PostConstruct;
+import java.util.Random;
+import java.util.function.Supplier;
+
+/**
+ * Trace ID generator for generating 64 bit trace IDs. This class is based on the {@link io.opentelemetry.sdk.trace.RandomIdGenerator}.
+ */
+@Slf4j
+@Component
+public class CustomIdGenerator implements IdGenerator {
+
+    @Autowired
+    private InspectitEnvironment env;
+
+    private static final long INVALID_ID = 0;
+
+    private static final Supplier<Random> randomSupplier = RandomSupplier.platformDefault();
+
+    private static boolean using64Bit = false;
+
+    public static boolean isUsing64Bit() {
+        return using64Bit;
+    }
+
+    @PostConstruct
+    public void initialize() {
+        setMode(env.getCurrentConfig().getTracing().isUse64BitTraceIds());
+    }
+
+    @EventListener
+    private void configEventListener(InspectitConfigChangedEvent event) {
+        boolean oldMode = event.getOldConfig().getTracing().isUse64BitTraceIds();
+        boolean newMode = event.getNewConfig().getTracing().isUse64BitTraceIds();
+
+        if (oldMode != newMode) {
+            setMode(newMode);
+        }
+    }
+
+    @VisibleForTesting
+    void setMode(boolean is64Bit) {
+        using64Bit = is64Bit;
+
+        if (using64Bit) {
+            log.info("Use of trace IDs with a length of 64 bits.");
+        } else {
+            log.info("Use of trace IDs with the default length (128 bits).");
+        }
+    }
+
+    @Override
+    public String generateSpanId() {
+        Random random = randomSupplier.get();
+        long id;
+        do {
+            id = random.nextLong();
+        } while (id == INVALID_ID);
+
+        return SpanId.fromLong(id);
+    }
+
+    @Override
+    public String generateTraceId() {
+        if (using64Bit) {
+            return generate64BitId();
+        } else {
+            return generate128BitId();
+        }
+    }
+
+    private String generate64BitId() {
+        Random random = randomSupplier.get();
+        long id;
+        do {
+            id = random.nextLong();
+        } while (id == INVALID_ID);
+        return TraceId.fromLongs(0L, id);
+    }
+
+    private String generate128BitId() {
+        Random random = randomSupplier.get();
+        long idHi = random.nextLong();
+        long idLo;
+        do {
+            idLo = random.nextLong();
+        } while (idLo == INVALID_ID);
+        return TraceId.fromLongs(idHi, idLo);
+    }
+
+    @Override
+    public String toString() {
+        return "RandomIdGenerator64Bit{}";
+    }
+}

inspectit-ocelot-core/src/test/java/rocks/inspectit/ocelot/core/opentelemetry/OpenTelemetryControllerImplIntTest.java

@@ -18,11 +18,13 @@
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
+import org.mockito.Mock;
 import org.springframework.beans.factory.annotation.Autowired;
 import rocks.inspectit.ocelot.config.model.exporters.ExporterEnabledState;
 import rocks.inspectit.ocelot.core.SLF4JBridgeHandlerUtils;
 import rocks.inspectit.ocelot.core.SpringTestBase;
 import rocks.inspectit.ocelot.core.exporter.LoggingTraceExporterService;
+import rocks.inspectit.ocelot.core.opentelemetry.trace.CustomIdGenerator;
 import rocks.inspectit.ocelot.core.utils.OpenTelemetryUtils;
 
 import java.io.IOException;

inspectit-ocelot-core/src/test/java/rocks/inspectit/ocelot/core/opentelemetry/OpenTelemetryControllerImplTest.java

@@ -24,6 +24,7 @@
 import rocks.inspectit.ocelot.config.model.InspectitConfig;
 import rocks.inspectit.ocelot.core.config.InspectitEnvironment;
 import rocks.inspectit.ocelot.core.exporter.DynamicallyActivatableMetricsExporterService;
+import rocks.inspectit.ocelot.core.opentelemetry.trace.CustomIdGenerator;
 import rocks.inspectit.ocelot.core.service.DynamicallyActivatableService;
 
 import java.lang.reflect.Method;
@@ -45,11 +46,15 @@ class OpenTelemetryControllerImplTest {
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     InspectitEnvironment env;
 
+    @Mock
+    CustomIdGenerator idGenerator;
+
     @BeforeEach
     void initOpenTelemetryController() {
         // mock max-export-batch-size to avoid exceptions
         when(env.getCurrentConfig().getTracing().getMaxExportBatchSize()).thenReturn(512);
         openTelemetryController.env = env;
+        openTelemetryController.idGenerator = idGenerator;
         openTelemetryController.init();
         openTelemetryController.start();
         clearInvocations(openTelemetryController);

inspectit-ocelot-core/src/test/java/rocks/inspectit/ocelot/core/opentelemetry/trace/CustomIdGeneratorTest.java

@@ -0,0 +1,66 @@
+package rocks.inspectit.ocelot.core.opentelemetry.trace;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.nio.charset.StandardCharsets;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@ExtendWith(MockitoExtension.class)
+public class CustomIdGeneratorTest {
+
+    int getBitSize(String string) {
+        return string.getBytes(StandardCharsets.UTF_8).length * 8;
+    }
+
+    @InjectMocks
+    CustomIdGenerator idGenerator;
+
+    @Nested
+    class TestGenerateSpanId {
+
+        @Test
+        public void is64Bit() {
+            String id = idGenerator.generateSpanId();
+            assertThat(getBitSize(id)).isEqualTo(128);
+        }
+    }
+
+    @Nested
+    class TestGenerateTraceId {
+
+        @Test
+        public void is64Bit() {
+            idGenerator.setMode(true);
+
+            String id = idGenerator.generateTraceId();
+
+            assertThat(id.substring(0,16)).isEqualTo("0000000000000000");
+            assertThat(getBitSize(id)).isEqualTo(256);
+        }
+
+
+        @Test
+        public void is128Bit() {
+            idGenerator.setMode(false);
+
+            String id = idGenerator.generateTraceId();
+
+            assertThat(id.substring(0,16)).isNotEqualTo("0000000000000000");
+            assertThat(getBitSize(id)).isEqualTo(256);
+        }
+
+        @Test
+        public void defaultMode() {
+            String id = idGenerator.generateTraceId();
+
+            assertThat(id.substring(0,16)).isNotEqualTo("0000000000000000");
+            assertThat(getBitSize(id)).isEqualTo(256);
+        }
+    }
+
+}

inspectit-ocelot-documentation/docs/tracing/tracing.md

@@ -68,4 +68,19 @@ Currently the following formats are supported for sending correlation informatio
 
 :::important
 It is important to note that this configuration refers to the format of the correlation information used to **send this data**. When processing correlation information that the agent receives, it automatically uses the correct format.
+:::
+
+### Using 64-Bit Trace IDs
+
+Since version 2.0.0, the inspectIT Ocelot Agent is able to generate trace IDs with a size of 64 bits instead of the 128 bit trace IDs used by default by the agent.
+The functionality that trace IDs with a length of 64 bits are generated can be activated with the following configuration:
+
+```YAML
+inspectit:
+  tracing:
+    use-64-bit-trace-ids: true
+```
+
+:::important
+Please note that some propagation formats do not support 64-bit Ids, such as the W3C "Trace Context". In this case the 64-bit trace IDs are padded with leading zeros.
 :::