Merge branch 'master' into leo.romanovsky/ffl-2693-java-agentless-configuration-source

Author: leoromanovsky

.gitlab/collect-result/CollectResults.java

@@ -3,12 +3,15 @@
 
 class CollectResults {
   public static void main(String[] args) throws Exception {
+    // Detect flaky jobs
+    var continueOnFailure = Boolean.parseBoolean(System.getenv("CONTINUE_ON_FAILURE"));
+    // Run collector
     var collector =
         new ResultCollector(
             Path.of("results"),
             Path.of("workspace"),
-            List.of(Path.of("workspace"), Path.of("buildSrc")));
-
+            List.of(Path.of("workspace"), Path.of("buildSrc")),
+            continueOnFailure);
     collector.collect();
   }
 }

.gitlab/collect-result/JUnitReport.java

@@ -153,6 +153,29 @@ void tagFinalStatuses() {
     }
   }
 
+  /// Marks every testcase as `test.final_status=skip` for jobs that tolerate failures.
+  ///
+  /// The flaky test jobs (`test_flaky`, `test_flaky_inst`) run with `CONTINUE_ON_FAILURE=true`, so
+  /// their result never gates the pipeline: it runs to completion regardless of pass or fail.
+  /// `test.final_status` records that CI impact rather than the raw outcome, so every test in these
+  /// jobs is `skip` — a failure is a non-blocking failure and a pass is a non-blocking pass. This
+  /// keeps flaky failures from creating false-positive notifications and skewing SLIs, while the
+  /// real per-test outcome stays available in `test.status` (derived from the `<failure>`,
+  /// `<error>`, and `<skipped>` children, which are left in place). Always-green tests that could
+  /// leave the flaky pipeline are then found with `@test.status:pass @test.final_status:skip`.
+  ///
+  /// **Must run before {@link #tagFinalStatuses()}** so the natural pass/fail status is never
+  /// assigned. Testcases already tagged by {@link #tagRetriedAttempts()} or
+  /// {@link #tagSyntheticFailures()} are left untouched (already `skip`).
+  void tagAllAsSkipped() {
+    for (var testcase : testcases()) {
+      if (hasFinalStatusProperty(testcase)) {
+        continue;
+      }
+      addFinalStatusProperty(testcase, "skip", MissingPropertiesPlacement.FIRST_CHILD);
+    }
+  }
+
   void write(Path xmlFile) throws Exception {
     Files.createDirectories(xmlFile.getParent());
     var tmpFile = Files.createTempFile(xmlFile.getParent(), "collect-results-", ".xml");

.gitlab/collect-result/ResultCollector.java

@@ -13,12 +13,15 @@ final class ResultCollector {
   private final Path resultsDir;
   private final Path workspaceDir;
   private final List<Path> searchDirs;
+  private final boolean continueOnFailure;
   private final SourceFileResolver sourceFileResolver;
 
-  ResultCollector(Path resultsDir, Path workspaceDir, List<Path> searchDirs) {
+  ResultCollector(
+      Path resultsDir, Path workspaceDir, List<Path> searchDirs, boolean continueOnFailure) {
     this.resultsDir = resultsDir;
     this.workspaceDir = workspaceDir;
     this.searchDirs = searchDirs;
+    this.continueOnFailure = continueOnFailure;
     this.sourceFileResolver = new SourceFileResolver(workspaceDir);
   }
 
@@ -32,6 +35,10 @@ void collect() throws Exception {
       return;
     }
 
+    if (continueOnFailure) {
+      System.out.println("CONTINUE_ON_FAILURE=true: reporting all tests as skip");
+    }
+
     System.out.println("Saving test results:");
     for (var sourceXml : findXmlFiles(testResultDirs)) {
       collect(sourceXml);
@@ -51,6 +58,11 @@ private void collect(Path sourceXml) throws Exception {
     report.tagRetriedAttempts();
     reportChangedBeforeFinalStatus |= report.normalizeStableTestNames();
     report.tagSyntheticFailures();
+    // Flaky jobs (CONTINUE_ON_FAILURE=true) never gate CI, so record every test as skip before
+    // assigning natural statuses (APMLP-1267).
+    if (continueOnFailure) {
+      report.tagAllAsSkipped();
+    }
     report.tagFinalStatuses();
     report.write(targetXml);
 

AGENTS.md

@@ -68,7 +68,7 @@ docs/                     Developer documentation (see below)
 
 - Title: imperative verb sentence describing user-visible change (e.g. "Fix span sampling rule parsing")
 - Labels: always add `tag: ai generated` and at least one `comp:` or `inst:` label + one `type:` label
-- Use `tag: no release note` for internal/refactoring changes
+- Use `tag: no release notes` for internal/refactoring changes
 - Open as draft first, convert to ready when reviewable
 
 ## Review Guidelines

CONTRIBUTING.md

@@ -118,7 +118,7 @@ Both pull requests and issues should be labelled with at least a component or an
 
 Labels are used to not only categorize but also alter the continuous integration behavior:
 
-* `tag: no release note` to exclude a pull request from the next release changelog. Use it when changes are not relevant to the users like:
+* `tag: no release notes` to exclude a pull request from the next release changelog. Use it when changes are not relevant to the users like:
   * Internal features changes
   * Refactoring pull requests
   * CI and build tools improvements

dd-java-agent/instrumentation/akka/akka-actor-2.5/build.gradle

@@ -16,11 +16,19 @@ apply from: "$rootDir/gradle/java.gradle"
 apply from: "$rootDir/gradle/test-with-scala.gradle"
 
 addTestSuite('akka23Test')
+addTestSuiteExtendingForDir('akka23ForkedTest', 'akka23Test', 'akka23Test')
 addTestSuiteForDir('latestDepTest', 'test')
+addTestSuiteExtendingForDir('latestDepForkedTest', 'latestDepTest', 'akka23Test')
 
 tasks.named("compileAkka23TestGroovy", GroovyCompile) {
   classpath += files(sourceSets.akka23Test.scala.classesDirectory)
 }
+tasks.named("compileAkka23ForkedTestGroovy", GroovyCompile) {
+  classpath += files(sourceSets.akka23ForkedTest.scala.classesDirectory)
+}
+tasks.named("compileLatestDepForkedTestGroovy", GroovyCompile) {
+  classpath += files(sourceSets.latestDepForkedTest.scala.classesDirectory)
+}
 
 // Run the akka23Test against the normal and latestDep akka version as well
 sourceSets {

dd-java-agent/instrumentation/akka/akka-actor-2.5/src/akka23Test/groovy/AkkaActorTest.groovy

@@ -1,10 +1,12 @@
 import datadog.trace.agent.test.InstrumentationSpecification
 import datadog.trace.api.config.TraceInstrumentationConfig
 import datadog.trace.bootstrap.instrumentation.api.Tags
+import spock.lang.AutoCleanup
 import spock.lang.Shared
 
 class AkkaActorTest extends InstrumentationSpecification {
   @Shared
+  @AutoCleanup
   def akkaTester = new AkkaActors()
 
   def "akka actor send #name #iterations"() {
@@ -84,7 +86,7 @@ class AkkaActorTest extends InstrumentationSpecification {
   }
 }
 
-class AkkaActorContextSwapTest extends AkkaActorTest {
+class AkkaActorContextSwapForkedTest extends AkkaActorTest {
   @Override
   void configurePreAgent() {
     super.configurePreAgent()

dd-java-agent/instrumentation/akka/akka-actor-2.5/src/akka23Test/scala/AkkaActors.scala

@@ -11,6 +11,7 @@ import datadog.trace.bootstrap.instrumentation.api.AgentTracer.{
   startSpan
 }
 
+import scala.concurrent.Await
 import scala.concurrent.duration._
 
 class AkkaActors extends AutoCloseable {
@@ -87,24 +88,18 @@ object AkkaActors {
     }
 
   // The way to terminate an actor system has changed between versions
-  val terminate: (ActorSystem) => Unit = {
-    val t =
-      try {
-        ActorSystem.getClass.getMethod("terminate")
-      } catch {
-        case _: Throwable =>
-          try {
-            ActorSystem.getClass.getMethod("awaitTermination")
-          } catch {
-            case _: Throwable => null
-          }
-      }
-    if (t ne null) {
-      { system: ActorSystem =>
-        t.invoke(system)
-      }
-    } else {
-      { _ => ??? }
+  val terminate: (ActorSystem) => Unit = { system =>
+    try {
+      classOf[ActorSystem].getMethod("terminate").invoke(system)
+      val whenTerminated = classOf[ActorSystem]
+        .getMethod("whenTerminated")
+        .invoke(system)
+        .asInstanceOf[scala.concurrent.Future[AnyRef]]
+      Await.ready(whenTerminated, 30.seconds)
+    } catch {
+      case _: NoSuchMethodException =>
+        classOf[ActorSystem].getMethod("shutdown").invoke(system)
+        classOf[ActorSystem].getMethod("awaitTermination").invoke(system)
     }
   }
 }

dd-java-agent/instrumentation/akka/akka-actor-2.5/src/main/java/datadog/trace/instrumentation/akka/concurrent/AkkaMailboxInstrumentation.java

@@ -4,25 +4,18 @@
 import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.checkpointActiveForRollback;
 import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.rollbackActiveToCheckpoint;
 import static datadog.trace.bootstrap.instrumentation.api.Java8BytecodeBridge.currentContext;
-import static java.util.Collections.singletonList;
 import static net.bytebuddy.matcher.ElementMatchers.isMethod;
 
 import com.google.auto.service.AutoService;
 import datadog.context.Context;
-import datadog.trace.agent.tooling.ExcludeFilterProvider;
 import datadog.trace.agent.tooling.Instrumenter;
 import datadog.trace.agent.tooling.InstrumenterModule;
 import datadog.trace.api.InstrumenterConfig;
-import datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter;
-import java.util.Collection;
-import java.util.EnumMap;
-import java.util.List;
-import java.util.Map;
 import net.bytebuddy.asm.Advice;
 
 @AutoService(InstrumenterModule.class)
 public class AkkaMailboxInstrumentation extends InstrumenterModule.ContextTracking
-    implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice, ExcludeFilterProvider {
+    implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice {
 
   public AkkaMailboxInstrumentation() {
     super("akka_actor_mailbox", "akka_actor", "akka_concurrent", "java_concurrent");
@@ -39,16 +32,6 @@ public void methodAdvice(MethodTransformer transformer) {
         isMethod().and(named("run")), getClass().getName() + "$SuppressMailboxRunAdvice");
   }
 
-  @Override
-  public Map<ExcludeFilter.ExcludeType, ? extends Collection<String>> excludedClasses() {
-    List<String> excludedClass = singletonList("akka.dispatch.MailBox");
-    EnumMap<ExcludeFilter.ExcludeType, Collection<String>> excludedTypes =
-        new EnumMap<>(ExcludeFilter.ExcludeType.class);
-    excludedTypes.put(ExcludeFilter.ExcludeType.RUNNABLE, excludedClass);
-    excludedTypes.put(ExcludeFilter.ExcludeType.FORK_JOIN_TASK, excludedClass);
-    return excludedTypes;
-  }
-
   /**
    * This instrumentation is defensive and closes all scopes on the scope stack that were not there
    * when we started processing this actor mailbox. The reason for that is twofold.

dd-java-agent/instrumentation/karate/karate-2.0/src/main/java/datadog/trace/instrumentation/karate2/KarateExecutionInstrumentation.java

@@ -0,0 +1,87 @@
+package datadog.trace.instrumentation.karate2;
+
+import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.isBridge;
+import static net.bytebuddy.matcher.ElementMatchers.not;
+import static net.bytebuddy.matcher.ElementMatchers.returns;
+import static net.bytebuddy.matcher.ElementMatchers.takesArgument;
+import static net.bytebuddy.matcher.ElementMatchers.takesArguments;
+import static net.bytebuddy.matcher.ElementMatchers.takesNoArguments;
+
+import com.google.auto.service.AutoService;
+import datadog.trace.agent.tooling.Instrumenter;
+import datadog.trace.agent.tooling.InstrumenterModule;
+import datadog.trace.api.Config;
+import java.util.Collections;
+import java.util.Map;
+
+/**
+ * Drives test-retry execution policies (ATR / EFD / attempt-to-fix) and failure suppression for
+ * Karate v2.
+ *
+ * <ul>
+ *   <li>{@code ScenarioRuntime#call()} is advised to re-run the scenario while the execution policy
+ *       is applicable, overriding the returned {@code ScenarioResult} with the final attempt.
+ *   <li>{@code ScenarioResult#addStepResult(StepResult)} is advised to replace a failing step with
+ *       a skipped one when the policy requests failure suppression.
+ * </ul>
+ *
+ * Compiled for Java 8 (see {@link KarateInstrumentation}); the advice lives in the {@code java21}
+ * source set.
+ */
+@AutoService(InstrumenterModule.class)
+public class KarateExecutionInstrumentation extends InstrumenterModule.CiVisibility
+    implements Instrumenter.ForKnownTypes, Instrumenter.HasMethodAdvice {
+
+  public KarateExecutionInstrumentation() {
+    super("ci-visibility", "karate", "test-retry");
+  }
+
+  @Override
+  public boolean isEnabled() {
+    return super.isEnabled() && Config.get().isCiVisibilityExecutionPoliciesEnabled();
+  }
+
+  @Override
+  public String[] knownMatchingTypes() {
+    return new String[] {"io.karatelabs.core.ScenarioRuntime", "io.karatelabs.core.ScenarioResult"};
+  }
+
+  @Override
+  public String[] helperClassNames() {
+    return new String[] {
+      packageName + ".KarateUtils",
+      packageName + ".TestEventsHandlerHolder",
+      packageName + ".ExecutionContext",
+      packageName + ".KarateTracingListener",
+      packageName + ".KarateScenarioAdvice",
+      packageName + ".KarateScenarioAdvice$RetryAdvice",
+      packageName + ".KarateScenarioAdvice$SuppressErrorAdvice"
+    };
+  }
+
+  @Override
+  public Map<String, String> contextStore() {
+    return Collections.singletonMap(
+        "io.karatelabs.gherkin.Scenario", packageName + ".ExecutionContext");
+  }
+
+  @Override
+  public void methodAdvice(MethodTransformer transformer) {
+    // ScenarioRuntime#call() is the run()-equivalent; match the concrete ScenarioResult-returning
+    // method, not the synthetic Callable#call() bridge.
+    transformer.applyAdvice(
+        named("call")
+            .and(takesNoArguments())
+            .and(returns(named("io.karatelabs.core.ScenarioResult")))
+            .and(not(isBridge())),
+        packageName + ".KarateScenarioAdvice$RetryAdvice");
+
+    // ScenarioResult#addStepResult(StepResult)
+    transformer.applyAdvice(
+        named("addStepResult")
+            .and(takesArguments(1))
+            .and(takesArgument(0, named("io.karatelabs.core.StepResult"))),
+        packageName + ".KarateScenarioAdvice$SuppressErrorAdvice");
+  }
+}