Make Config / InstrumenterConfig modifiable via a load-time test agent (#11397)

test: replace WithConfigExtension's retransform agent with a premain agent

The JUnit 5 WithConfigExtension used ByteBuddy retransformation at
@BeforeAll to make Config and InstrumenterConfig INSTANCE fields
public/volatile/non-final. Retransformation is not guaranteed when the
class has been loaded before the extension runs (e.g. through
CoreTracer), which caused intermittent failures on at least HotSpot 1.8,
IBM J9, and OpenJ9 Semeru jobs.

This commit switches to a load-time javaagent that rewrites the INSTANCE
fields upon class cload.

It introduces in particular `dd-trace-java.modifiable-config` convention
plugin whose role is to configure the test jvm with the java agent to
every Test task. This convention plugin is applied automatically via
dd-trace-java.configure-tests which is itself applied via
java_no_deps.gradle.

`WithConfigExtension` no longer installs a ByteBuddy agent
programmatically; instead it just verifies the fields are already
modifiable.

refactor: simplify WithConfigExtension now that load-time agent guarantees writable Config fields

With modifiable-config-agent attached to every test JVM, the `INSTANCE`
fields of `Config` and `InstrumenterConfig` are always
`public`/`volatile`/non-`final`
by the time `WithConfigExtension` is loaded. The runtime state
machine that previously guarded the ByteBuddy retransform is therefore
dead code.

Collapse it:
- Move reflective lookups of the INSTANCE fields and default constructors
  into a static {} block that first calls
  ensureConfigInstrumentationHasBeenApplied() and then caches the
  handles as static finals. Failure throws ExceptionInInitializerError,
  which surfaces as a clear test-class load failure pointing at the
  Gradle convention plugin.
- Remove the isConfigInstanceModifiable / configModificationFailed /
  configTransformerInstalled flags and every guard they fed.
- Drop makeConfigInstanceModifiable(), checkConfigTransformation(),
  and checkWritable() — all redundant with the static-init check.
- Drop the corresponding JUnit assert* static imports.
- beforeAll/beforeEach/afterEach/afterAll now call rebuildConfig()
  unconditionally.
- Update the class Javadoc to reflect the new mechanism.

Co-Authored-By: Claude <noreply@anthropic.com>

ci: trigger non-default JVM tests

[ci: NON_DEFAULT_JVMS]

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

revert: Mark PendingTraceBufferTest tests flaky (#11383)

chore: make spotless happy

[ci: NON_DEFAULT_JVMS]

fix(build): skip modifiable-config agent when Test JVM already has -javaagent

The `dd-trace-java.modifiable-config` convention plugin unconditionally
attached a second `-javaagent:modifiable-config-agent.jar` to every Test
JVM. That breaks the few modules whose tests already launch with the real
dd-java-agent attached (currently only `:dd-java-agent`'s integration
tests, via the `doFirst` at `dd-java-agent/build.gradle:454-457`):

  * `AgentBootstrap.installAgentJar` tries the class' CodeSource first,
    then `getAgentFileFromJavaagentArg`, then a ClassLoader-resource
    lookup. On the failing matrix the CodeSource is null for the
    bootstrap class, so it falls through to the `-javaagent:` arg.
  * `getAgentFileFromJavaagentArg` refuses to pick when more than one
    `-javaagent:` is present ("multiple javaagents specified") and
    returns null.
  * The ClassLoader fallback then throws `IllegalArgumentException: URI
    is not absolute` for the bootstrap class URL.

Net effect: the tracing agent never installs and suites like
`OpenTracingTest` / `ShadowPackageRenamingTest` fail across non-default
JVMs (ibm8, semeru11/17, zulu11, tip).

Alternatives considered and rejected:

  * Manifest scan in `getAgentFileFromJavaagentArg` to pick the entry
    whose `Main-Class` is `AgentBootstrap`: meaningful bootstrap-
    performance cost (open every `-javaagent:` jar, read MANIFEST.MF)
    on a hot path that runs on every JVM startup.
  * `-Ddd.agent.jar.path` / `DD_AGENT_JAR_PATH`: no equivalent knob
    exists today, adds an attacker-controllable file path, and only
    helps when the CLI is already ambiguous — not worth the surface.

Skipping is safe for `:dd-java-agent`'s tests: nothing under
`dd-java-agent/src/test` (Java or Groovy) references
`Config` / `InstrumenterConfig` `INSTANCE`, and nothing uses
`WithConfigExtension`. The tests rely on the real agent's startup to
populate `Config.INSTANCE`, not on swapping the singleton mid-test.

Implementation: defer the attach to a `doFirst` that inspects
`allJvmArgs` for an existing non-modifiable-config `-javaagent:` entry.
Gradle prepends each new `doFirst`, so the plugin's check runs after
the project's own agent-attach `doFirst` and sees the real arg before
the JVM forks. When skipping, emit an `INFO`-level log so the decision
is visible under `--info`.

[ci: NON_DEFAULT_JVMS]

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Increase timeout to pass for ibm8

filling the delaying buffer for test bufferFullYieldsImmediateWrite
takes more than 5 seconds on ibm8 and CI
[ci: NON_DEFAULT_JVMS]

Merge branch 'master' into bdu/moves-with-config-extension-agent-to-commandline-via-convention-plugin

Co-authored-by: jpbempel <jean-philippe.bempel@datadoghq.com>
Co-authored-by: devflow.devflow-routing-intake <devflow.devflow-routing-intake@kubernetes.us1.ddbuild.io>

Author: 3 people

buildSrc/build.gradle.kts

@@ -101,6 +101,7 @@ dependencies {
 
 tasks.compileKotlin {
   dependsOn(":call-site-instrumentation-plugin:build")
+  dependsOn(":modifiable-config-agent:build")
 }
 
 testing {

buildSrc/modifiable-config-agent/build.gradle.kts

@@ -0,0 +1,41 @@
+plugins {
+  java
+  id("com.gradleup.shadow") version "8.3.9"
+}
+
+java {
+  sourceCompatibility = JavaVersion.VERSION_1_8
+  targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+apply {
+  from("$rootDir/../gradle/repositories.gradle")
+}
+
+dependencies {
+  implementation(libs.asm)
+}
+
+tasks {
+  shadowJar {
+    archiveClassifier.set("")
+    relocate("org.objectweb.asm", "datadog.trace.agent.test.config.shaded.asm")
+    manifest {
+      attributes(
+        mapOf(
+          "Premain-Class" to "datadog.trace.agent.test.config.ModifiableConfigAgent",
+          "Can-Retransform-Classes" to "false",
+          "Can-Redefine-Classes" to "false",
+        ),
+      )
+    }
+  }
+
+  jar {
+    enabled = false
+  }
+
+  build {
+    dependsOn(shadowJar)
+  }
+}

buildSrc/modifiable-config-agent/src/main/java/datadog/trace/agent/test/config/ModifiableConfigAgent.java

@@ -0,0 +1,80 @@
+package datadog.trace.agent.test.config;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.lang.instrument.IllegalClassFormatException;
+import java.lang.instrument.Instrumentation;
+import java.security.ProtectionDomain;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.Opcodes;
+
+/**
+ * Test-only Java agent that rewrites the {@code INSTANCE} field of {@code
+ * datadog.trace.api.Config} and {@code datadog.trace.api.InstrumenterConfig} to be public,
+ * volatile, and non-final, so tests can swap the singleton with a freshly-built instance.
+ *
+ * <p>Unlike a JUnit 5 extension that uses ByteBuddy to retransform the classes, this agent runs
+ * before any class is loaded, so the rewrite is guaranteed regardless of which class touches the
+ * config first.
+ */
+public final class ModifiableConfigAgent {
+
+  private static final String CONFIG = "datadog/trace/api/Config";
+  private static final String INST_CONFIG = "datadog/trace/api/InstrumenterConfig";
+  private static final String INSTANCE = "INSTANCE";
+
+  private ModifiableConfigAgent() {}
+
+  public static void premain(String args, Instrumentation inst) {
+    inst.addTransformer(new InstanceFieldRewriter(), false);
+  }
+
+  static final class InstanceFieldRewriter implements ClassFileTransformer {
+    @Override
+    public byte[] transform(
+        ClassLoader loader,
+        String className,
+        Class<?> classBeingRedefined,
+        ProtectionDomain protectionDomain,
+        byte[] classfileBuffer)
+        throws IllegalClassFormatException {
+      if (className == null) {
+        return null;
+      }
+      if (!CONFIG.equals(className) && !INST_CONFIG.equals(className)) {
+        return null;
+      }
+      try {
+        ClassReader reader = new ClassReader(classfileBuffer);
+        ClassWriter writer = new ClassWriter(reader, 0);
+        reader.accept(new InstanceFieldClassVisitor(writer), 0);
+        return writer.toByteArray();
+      } catch (Throwable t) {
+        System.err.println(
+            "[modifiable-config-agent] failed to rewrite " + className + ": " + t);
+        return null;
+      }
+    }
+  }
+
+  static final class InstanceFieldClassVisitor extends ClassVisitor {
+    InstanceFieldClassVisitor(ClassVisitor cv) {
+      super(Opcodes.ASM9, cv);
+    }
+
+    @Override
+    public FieldVisitor visitField(
+        int access, String name, String descriptor, String signature, Object value) {
+      if (INSTANCE.equals(name)) {
+        int rewritten =
+            (access & ~(Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED | Opcodes.ACC_FINAL))
+                | Opcodes.ACC_PUBLIC
+                | Opcodes.ACC_VOLATILE;
+        return super.visitField(rewritten, name, descriptor, signature, value);
+      }
+      return super.visitField(access, name, descriptor, signature, value);
+    }
+  }
+}

buildSrc/settings.gradle.kts

@@ -1,4 +1,5 @@
 include(":call-site-instrumentation-plugin")
+include(":modifiable-config-agent")
 
 dependencyResolutionManagement {
   versionCatalogs {

buildSrc/src/main/kotlin/dd-trace-java.configure-tests.gradle.kts

@@ -10,6 +10,10 @@ import org.gradle.testing.base.TestingExtension
 import java.time.Duration
 import java.time.temporal.ChronoUnit
 
+plugins {
+  id("dd-trace-java.modifiable-config")
+}
+
 // Need concrete implementation of BuildService in Kotlin
 abstract class ForkedTestLimit : BuildService<BuildServiceParameters.None>
 // Forked tests will fail with OOM if the memory is set too high. Gitlab allows at least a limit of 3.

buildSrc/src/main/kotlin/dd-trace-java.modifiable-config.gradle.kts

@@ -0,0 +1,42 @@
+import org.gradle.api.tasks.testing.Test
+import org.gradle.kotlin.dsl.withType
+
+/**
+ * Attaches the modifiable-config Java agent to every Test task so that
+ * `datadog.trace.api.Config` and `datadog.trace.api.InstrumenterConfig` have
+ * their `INSTANCE` field rewritten as public/volatile/non-final at load time.
+ *
+ * This is the load-time counterpart to
+ * `datadog.trace.junit.utils.config.WithConfigExtension`, which uses ByteBuddy
+ * to retransform the same classes at runtime. Retransformation does not always
+ * succeed when the class has been touched before the JUnit lifecycle starts
+ * (e.g. through `CoreTracer`); the agent guarantees the rewrite by intercepting
+ * the class before it is defined.
+ *
+ * The agent jar is built by the `:modifiable-config-agent` buildSrc subproject
+ * and is produced eagerly because the parent `buildSrc` compilation depends on
+ * it.
+ */
+val agentJar = rootProject.layout.projectDirectory
+  .file("buildSrc/modifiable-config-agent/build/libs/modifiable-config-agent.jar")
+  .asFile
+
+tasks.withType<Test>().configureEach {
+  inputs.file(agentJar).withPathSensitivity(org.gradle.api.tasks.PathSensitivity.NONE)
+  // Attach lazily so we can skip when the Test JVM already has another -javaagent.
+  // doFirst prepends, so this runs after any -javaagent registered later via doFirst.
+  doFirst {
+    val foreignAgent = allJvmArgs.firstOrNull {
+      it.startsWith("-javaagent:") && !it.contains("modifiable-config-agent")
+    }
+    if (foreignAgent != null) {
+      logger.info(
+        "[modifiable-config] skipping attach for {} — another -javaagent already present: {}",
+        path,
+        foreignAgent,
+      )
+    } else {
+      jvmArgs("-javaagent:${agentJar.absolutePath}")
+    }
+  }
+}

dd-trace-core/src/test/java/datadog/trace/core/PendingTraceBufferTest.java

@@ -35,7 +35,6 @@
 import datadog.trace.core.propagation.PropagationTags;
 import datadog.trace.core.scopemanager.ContinuableScopeManager;
 import datadog.trace.test.util.DDJavaSpecification;
-import datadog.trace.test.util.Flaky;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -57,7 +56,7 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
 
-@Timeout(5)
+@Timeout(10)
 public class PendingTraceBufferTest extends DDJavaSpecification {
 
   private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
@@ -196,7 +195,6 @@ void prioritySamplingIsAlwaysSent() {
     assertTrue(metadataChecker.hasSamplingPriority);
   }
 
-  @Flaky("Flaky on ibm8, semeru8, and semeru17 JVMs after migration from Groovy to JUnit")
   @Test
   void bufferFullYieldsImmediateWrite() {
     int capacity = delayingBuffer.getQueue().capacity();
@@ -221,7 +219,6 @@ void bufferFullYieldsImmediateWrite() {
     assertEquals(0, pendingTrace.getIsEnqueued());
   }
 
-  @Flaky("Flaky on ibm8, semeru8, and semeru17 JVMs after migration from Groovy to JUnit")
   @Test
   void longRunningTraceBufferFullDoesNotTriggerWrite() {
     int capacity = delayingBuffer.getQueue().capacity();
@@ -381,7 +378,6 @@ public boolean writeOnBufferFull() {
     assertEquals(3, counter.get());
   }
 
-  @Flaky("Flaky on semeru17 JVM after migration from Groovy to JUnit")
   @Test
   void samePendingTraceIsNotEnqueuedMultipleTimes() {
     when(tracer.getPartialFlushMinSpans()).thenReturn(10000);

utils/junit-utils/build.gradle.kts

@@ -5,8 +5,6 @@ plugins {
 apply(from = "$rootDir/gradle/java.gradle")
 
 dependencies {
-  api(libs.bytebuddy)
-  api(libs.bytebuddyagent)
   api(libs.forbiddenapis)
   api(project(":components:environment"))