Merge branch 'master' into bdu/skip-spotless-on-check-base

bric3 · web-flow · commit 916c68d314b9 · 2025-12-10T17:44:06.000+01:00
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
@@ -728,7 +728,7 @@ test_smoke:
     GRADLE_PARAMS: "-PskipFlakyTests"
     CACHE_TYPE: "smoke"
   parallel:
-    matrix: *test_matrix_4
+    matrix: *test_matrix_6
 
 test_ssi_smoke:
   extends: .test_job
@@ -739,7 +739,7 @@ test_ssi_smoke:
     DD_INJECT_FORCE: "true"
     DD_INJECTION_ENABLED: "tracer"
   parallel:
-    matrix: *test_matrix_4
+    matrix: *test_matrix_6
 
 test_smoke_graalvm:
   extends: .test_job
diff --git a/dd-java-agent/agent-debugger/src/main/java/com/datadog/debugger/probe/LogProbe.java b/dd-java-agent/agent-debugger/src/main/java/com/datadog/debugger/probe/LogProbe.java
@@ -504,7 +504,7 @@ public void evaluate(
     LogStatus logStatus = (LogStatus) status;
     if (!hasCondition()) {
       if (singleProbe) {
-        // sampling was already done in isReadToCapture so we assume that if we are executing the
+        // sampling was already done in isReadyToCapture so we assume that if we are executing the
         // current method it means the status should be sampled
         if (!logStatus.getDebugSessionStatus().isDisabled()) {
           logStatus.setSampled(true);
diff --git a/dd-java-agent/agent-debugger/src/test/java/com/datadog/debugger/sink/SnapshotSinkTest.java b/dd-java-agent/agent-debugger/src/test/java/com/datadog/debugger/sink/SnapshotSinkTest.java
@@ -29,6 +29,7 @@
 import java.util.List;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledIf;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
@@ -72,6 +73,9 @@ void setUp() {
 
   @ParameterizedTest(name = "Process tags enabled ''{0}''")
   @ValueSource(booleans = {true, false})
+  @DisabledIf(
+      value = "datadog.environment.JavaVirtualMachine#isJ9",
+      disabledReason = "Flaky on J9 JVMs")
   public void addHighRateSnapshot(boolean processTagsEnabled) throws IOException {
     when(config.isExperimentalPropagateProcessTagsEnabled()).thenReturn(processTagsEnabled);
     ProcessTags.reset(config);
diff --git a/dd-java-agent/instrumentation-testing/src/main/groovy/datadog/trace/agent/test/TrackingSpanDecorator.groovy b/dd-java-agent/instrumentation-testing/src/main/groovy/datadog/trace/agent/test/TrackingSpanDecorator.groovy
@@ -134,6 +134,11 @@ class TrackingSpanDecorator implements AgentSpan {
     return delegate.setTag(key, value)
   }
 
+  @Override
+  AgentSpan setTag(String key, float value) {
+    return delegate.setTag(key, value)
+  }
+
   @Override
   AgentSpan setTag(String key, double value) {
     return delegate.setTag(key, value)
diff --git a/dd-java-agent/instrumentation-testing/src/main/groovy/datadog/trace/agent/test/base/HttpServerTest.groovy b/dd-java-agent/instrumentation-testing/src/main/groovy/datadog/trace/agent/test/base/HttpServerTest.groovy
@@ -2348,7 +2348,6 @@ abstract class HttpServerTest<SERVER> extends WithHttpServer<SERVER> {
   /**
    * This test should be done in a forked test class
    */
-  @Flaky("https://datadoghq.atlassian.net/browse/APMLP-785")
   def "test rum injection in head for mime #mime"() {
     setup:
     assumeTrue(testRumInjection())
diff --git a/dd-java-agent/instrumentation/kafka/kafka-connect-0.11/build.gradle b/dd-java-agent/instrumentation/kafka/kafka-connect-0.11/build.gradle
@@ -4,6 +4,9 @@ muzzle {
     module = "connect-runtime"
     versions = "[0.11.0.0,)"
     javaVersion = "17"
+    excludeDependency "io.confluent.cloud:*"
+    excludeDependency "io.confluent.observability:*"
+    excludeDependency "io.confluent.secure.compute:*"
     assertInverse = true
   }
 }
diff --git a/dd-java-agent/instrumentation/spring/spring-webmvc/spring-webmvc-3.1/src/test/groovy/test/boot/SpringBootBasedTest.groovy b/dd-java-agent/instrumentation/spring/spring-webmvc/spring-webmvc-3.1/src/test/groovy/test/boot/SpringBootBasedTest.groovy
@@ -144,11 +144,6 @@ class SpringBootBasedTest extends HttpServerTest<ConfigurableApplicationContext>
     true
   }
 
-  @Override
-  boolean testRumInjection() {
-    true
-  }
-
   @Override
   void assertEndpointDiscovery(final List<?> endpoints) {
     final discovered = endpoints.collectEntries { [(it.method): it] }  as Map<String, Endpoint>
@@ -604,3 +599,10 @@ class SpringBootBasedTest extends HttpServerTest<ConfigurableApplicationContext>
     }
   }
 }
+
+class SpringBootRumInjectionForkedTest extends SpringBootBasedTest {
+  @Override
+  boolean testRumInjection() {
+    true
+  }
+}
diff --git a/dd-java-agent/instrumentation/synapse-3.0/src/main/java/datadog/trace/instrumentation/synapse3/SynapseServerInstrumentation.java b/dd-java-agent/instrumentation/synapse-3.0/src/main/java/datadog/trace/instrumentation/synapse3/SynapseServerInstrumentation.java
@@ -2,6 +2,7 @@
 
 import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named;
 import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.namedOneOf;
+import static datadog.trace.bootstrap.instrumentation.api.Java8BytecodeBridge.getRootContext;
 import static datadog.trace.bootstrap.instrumentation.api.Java8BytecodeBridge.spanFromContext;
 import static datadog.trace.instrumentation.synapse3.SynapseServerDecorator.DECORATE;
 import static datadog.trace.instrumentation.synapse3.SynapseServerDecorator.SYNAPSE_CONTEXT_KEY;
@@ -125,7 +126,7 @@ public static void errorResponse(
         @Advice.Argument(value = 1, optional = true) final Object error) {
       // check and remove context so it won't be finished twice
       Context context = (Context) connection.getContext().removeAttribute(SYNAPSE_CONTEXT_KEY);
-      if (null != context && context != Context.root()) {
+      if (null != context && context != getRootContext()) {
         AgentSpan span = spanFromContext(context);
         if (null != span) {
           if (error instanceof Throwable) {
diff --git a/dd-smoke-tests/debugger-integration-tests/src/test/java/datadog/smoketest/TracerDebuggerIntegrationTest.java b/dd-smoke-tests/debugger-integration-tests/src/test/java/datadog/smoketest/TracerDebuggerIntegrationTest.java
@@ -12,6 +12,7 @@
 import datadog.trace.agent.test.utils.PortUtils;
 import datadog.trace.bootstrap.debugger.MethodLocation;
 import datadog.trace.bootstrap.debugger.ProbeId;
+import datadog.trace.test.util.Flaky;
 import datadog.trace.test.util.NonRetryable;
 import datadog.trace.util.TagsHelper;
 import java.io.IOException;
@@ -30,6 +31,7 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
+@Flaky
 @NonRetryable
 public class TracerDebuggerIntegrationTest extends BaseIntegrationTest {
 
diff --git a/dd-trace-core/src/main/java/datadog/trace/core/DDSpan.java b/dd-trace-core/src/main/java/datadog/trace/core/DDSpan.java
@@ -432,6 +432,12 @@ public DDSpan setTag(final String tag, final long value) {
     return this;
   }
 
+  @Override
+  public DDSpan setTag(final String tag, final float value) {
+    context.setTag(tag, value);
+    return this;
+  }
+
   @Override
   public DDSpan setTag(final String tag, final double value) {
     context.setTag(tag, value);
diff --git a/dd-trace-core/src/main/java/datadog/trace/core/DDSpanContext.java b/dd-trace-core/src/main/java/datadog/trace/core/DDSpanContext.java
@@ -76,6 +76,8 @@ public class DDSpanContext
   /** The collection of all span related to this one */
   private final TraceCollector traceCollector;
 
+  private final TagInterceptor tagInterceptor;
+
   /** Baggage is associated with the whole trace and shared with other spans */
   private volatile Map<String, String> baggageItems;
 
@@ -330,6 +332,7 @@ public DDSpanContext(
 
     assert traceCollector != null;
     this.traceCollector = traceCollector;
+    this.tagInterceptor = this.traceCollector.getTracer().getTagInterceptor();
 
     assert traceId != null;
     this.traceId = traceId;
@@ -766,9 +769,122 @@ public void setTag(final String tag, final Object value) {
       synchronized (unsafeTags) {
         unsafeTags.remove(tag);
       }
-    } else if (!traceCollector.getTracer().getTagInterceptor().interceptTag(this, tag, value)) {
+    } else if (!tagInterceptor.interceptTag(this, tag, value)) {
+      synchronized (unsafeTags) {
+        unsafeTags.set(tag, value);
+      }
+    }
+  }
+
+  public void setTag(final String tag, final String value) {
+    if (null == tag) {
+      return;
+    }
+    if (null == value) {
+      synchronized (unsafeTags) {
+        unsafeTags.remove(tag);
+      }
+    } else if (!tagInterceptor.interceptTag(this, tag, value)) {
+      synchronized (unsafeTags) {
+        unsafeTags.set(tag, value);
+      }
+    }
+  }
+
+  /*
+   * Uses to determine if there's an opportunity to avoid primitve boxing.
+   * If the underlying map doesn't support efficient primitives, then boxing is used.
+   * If the tag may be intercepted, then boxing is also used.
+   */
+  private boolean precheckIntercept(String tag) {
+    // Usually only a single instanceof TagMap will be loaded,
+    // so isOptimized is turned into a direct call and then inlines to a constant
+    // Since isOptimized just returns a constant - doesn't require synchronization
+    return !unsafeTags.isOptimized() || tagInterceptor.needsIntercept(tag);
+  }
+
+  /*
+   * Used when precheckIntercept determines that boxing is unavoidable
+   *
+   * Either because the tagInterceptor needs to be fully checked (which requires boxing)
+   * In that case, a box has already been created so it makes sense to pass the box
+   * onto TagMap, since optimized TagMap will cache the box
+   *
+   * -- OR --
+   *
+   * The TagMap isn't optimized and will need to box the primitive regardless of
+   * tag interception
+   */
+  private void setBox(String tag, Object box) {
+    if (!tagInterceptor.interceptTag(this, tag, box)) {
+      synchronized (unsafeTags) {
+        unsafeTags.set(tag, box);
+      }
+    }
+  }
+
+  public void setTag(final String tag, final boolean value) {
+    if (null == tag) {
+      return;
+    }
+    if (precheckIntercept(tag)) {
+      this.setBox(tag, value);
+    } else {
       synchronized (unsafeTags) {
-        unsafeSetTag(tag, value);
+        unsafeTags.set(tag, value);
+      }
+    }
+  }
+
+  public void setTag(final String tag, final int value) {
+    if (null == tag) {
+      return;
+    }
+    if (precheckIntercept(tag)) {
+      this.setBox(tag, value);
+    } else {
+      synchronized (unsafeTags) {
+        unsafeTags.set(tag, value);
+      }
+    }
+  }
+
+  public void setTag(final String tag, final long value) {
+    if (null == tag) {
+      return;
+    }
+    // check needsIntercept first to avoid unnecessary boxing
+    boolean intercepted =
+        tagInterceptor.needsIntercept(tag) && tagInterceptor.interceptTag(this, tag, value);
+    if (!intercepted) {
+      synchronized (unsafeTags) {
+        unsafeTags.set(tag, value);
+      }
+    }
+  }
+
+  public void setTag(final String tag, final float value) {
+    if (null == tag) {
+      return;
+    }
+    if (precheckIntercept(tag)) {
+      this.setBox(tag, value);
+    } else {
+      synchronized (unsafeTags) {
+        unsafeTags.set(tag, value);
+      }
+    }
+  }
+
+  public void setTag(final String tag, final double value) {
+    if (null == tag) {
+      return;
+    }
+    if (precheckIntercept(tag)) {
+      this.setBox(tag, value);
+    } else {
+      synchronized (unsafeTags) {
+        unsafeTags.set(tag, value);
       }
     }
   }
@@ -789,12 +905,11 @@ void setAllTags(final TagMap map, boolean needsIntercept) {
         // to avoid using a capturing lambda
         map.forEach(
             this,
-            traceCollector.getTracer().getTagInterceptor(),
-            (ctx, tagInterceptor, tagEntry) -> {
+            (ctx, tagEntry) -> {
               String tag = tagEntry.tag();
               Object value = tagEntry.objectValue();
 
-              if (!tagInterceptor.interceptTag(ctx, tag, value)) {
+              if (!ctx.tagInterceptor.interceptTag(ctx, tag, value)) {
                 ctx.unsafeTags.set(tagEntry);
               }
             });
@@ -809,7 +924,6 @@ void setAllTags(final TagMap.Ledger ledger) {
       return;
     }
 
-    TagInterceptor tagInterceptor = traceCollector.getTracer().getTagInterceptor();
     synchronized (unsafeTags) {
       for (final TagMap.EntryChange entryChange : ledger) {
         if (entryChange.isRemoval()) {
@@ -834,7 +948,6 @@ void setAllTags(final Map<String, ?> map) {
     } else if (map instanceof TagMap) {
       setAllTags((TagMap) map);
     } else if (!map.isEmpty()) {
-      TagInterceptor tagInterceptor = traceCollector.getTracer().getTagInterceptor();
       synchronized (unsafeTags) {
         for (final Map.Entry<String, ?> tag : map.entrySet()) {
           if (!tagInterceptor.interceptTag(this, tag.getKey(), tag.getValue())) {
@@ -846,7 +959,19 @@ void setAllTags(final Map<String, ?> map) {
   }
 
   void unsafeSetTag(final String tag, final Object value) {
-    unsafeTags.put(tag, value);
+    unsafeTags.set(tag, value);
+  }
+
+  void unsafeSetTag(final String tag, final CharSequence value) {
+    unsafeTags.set(tag, value);
+  }
+
+  void unsafeSetTag(final String tag, final byte value) {
+    unsafeTags.set(tag, value);
+  }
+
+  void unsafeSetTag(final String tag, final double value) {
+    unsafeTags.set(tag, value);
   }
 
   Object getTag(final String key) {
diff --git a/dd-trace-core/src/test/groovy/datadog/trace/core/PendingTraceBufferTest.groovy b/dd-trace-core/src/test/groovy/datadog/trace/core/PendingTraceBufferTest.groovy
diff --git a/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentSpan.java b/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentSpan.java
diff --git a/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/ImmutableSpan.java b/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/ImmutableSpan.java

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,9 @@ muzzle {`
`4`	`4`	`module = "connect-runtime"`
`5`	`5`	`versions = "[0.11.0.0,)"`
`6`	`6`	`javaVersion = "17"`
	`7`	`+ excludeDependency "io.confluent.cloud:*"`
	`8`	`+ excludeDependency "io.confluent.observability:*"`
	`9`	`+ excludeDependency "io.confluent.secure.compute:*"`
`7`	`10`	`assertInverse = true`
`8`	`11`	`}`
`9`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -144,11 +144,6 @@ class SpringBootBasedTest extends HttpServerTest<ConfigurableApplicationContext>`
`144`	`144`	`true`
`145`	`145`	`}`
`146`	`146`
`147`		`- @Override`
`148`		`- boolean testRumInjection() {`
`149`		`- true`
`150`		`- }`
`151`		`-`
`152`	`147`	`@Override`
`153`	`148`	`void assertEndpointDiscovery(final List<?> endpoints) {`
`154`	`149`	`final discovered = endpoints.collectEntries { [(it.method): it] } as Map<String, Endpoint>`
`@@ -604,3 +599,10 @@ class SpringBootBasedTest extends HttpServerTest<ConfigurableApplicationContext>`
`604`	`599`	`}`
`605`	`600`	`}`
`606`	`601`	`}`
	`602`	`+`
	`603`	`+class SpringBootRumInjectionForkedTest extends SpringBootBasedTest {`
	`604`	`+ @Override`
	`605`	`+ boolean testRumInjection() {`
	`606`	`+ true`
	`607`	`+ }`
	`608`	`+}`