Merge branch 'master' into alejandro.gonzalez/APPSEC-61873-3

Author: jandro996

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

@@ -46,6 +46,9 @@ tasks.withType<Test>().configureEach {
   // Use a task-specific user prefs directory
   systemProperty("java.util.prefs.userRoot", layout.buildDirectory.dir("tmp/userPrefs/$name").get().asFile.absolutePath)
 
+  // Enable JUnit 5 auto-detection so ConfigInversionExtension (STRICT mode) is loaded automatically
+  systemProperty("junit.jupiter.extensions.autodetection.enabled", "true")
+
   // Split up tests that want to run forked in their own separate JVM for generated tasks
   if (name.startsWith("forkedTest") || name.endsWith("ForkedTest")) {
     setExcludes(emptyList())

dd-java-agent/agent-bootstrap/src/main/java/datadog/trace/bootstrap/instrumentation/decorator/AsyncResultDecorator.java

@@ -11,17 +11,6 @@
  */
 public abstract class AsyncResultDecorator extends BaseDecorator {
 
-  private static final ClassValue<AsyncResultExtension> EXTENSION_CLASS_VALUE =
-      new ClassValue<AsyncResultExtension>() {
-        @Override
-        protected AsyncResultExtension computeValue(Class<?> type) {
-          return AsyncResultExtensions.registered().stream()
-              .filter(extension -> extension.supports(type))
-              .findFirst()
-              .orElse(null);
-        }
-      };
-
   /**
    * Look for asynchronous result and decorate it with span finisher. If the result is not
    * asynchronous, it will be return unmodified and span will be finished.
@@ -33,12 +22,9 @@ protected AsyncResultExtension computeValue(Class<?> type) {
    */
   public Object wrapAsyncResultOrFinishSpan(
       final Object result, final Class<?> methodReturnType, final AgentSpan span) {
-    AsyncResultExtension extension;
-    if (result != null && (extension = EXTENSION_CLASS_VALUE.get(methodReturnType)) != null) {
-      Object applied = extension.apply(result, span);
-      if (applied != null) {
-        return applied;
-      }
+    Object applied = AsyncResultExtensions.wrapAsyncResult(result, methodReturnType, span);
+    if (applied != null) {
+      return applied;
     }
     // If no extension was applied, immediately finish the span and return the original result
     span.finish();

dd-java-agent/agent-bootstrap/src/main/java/datadog/trace/bootstrap/instrumentation/java/concurrent/AsyncResultExtensions.java

@@ -16,6 +16,32 @@ public final class AsyncResultExtensions {
   private static final List<AsyncResultExtension> EXTENSIONS =
       new CopyOnWriteArrayList<>(singletonList(new CompletableAsyncResultExtension()));
 
+  private static final ClassValue<AsyncResultExtension> EXTENSION_CLASS_VALUE =
+      new ClassValue<AsyncResultExtension>() {
+        @Override
+        protected AsyncResultExtension computeValue(Class<?> type) {
+          return EXTENSIONS.stream()
+              .filter(extension -> extension.supports(type))
+              .findFirst()
+              .orElse(null);
+        }
+      };
+
+  /**
+   * Wraps a supported async result so the span is finished when the async computation completes.
+   *
+   * @return the wrapped async result, or {@code null} if the result type is unsupported or no
+   *     wrapping is applied
+   */
+  public static Object wrapAsyncResult(
+      final Object result, final Class<?> resultType, final AgentSpan span) {
+    AsyncResultExtension extension;
+    if (result != null && (extension = EXTENSION_CLASS_VALUE.get(resultType)) != null) {
+      return extension.apply(result, span);
+    }
+    return null;
+  }
+
   /**
    * Registers an extension to add supported async types.
    *
@@ -36,11 +62,6 @@ public static void register(AsyncResultExtension extension) {
     }
   }
 
-  /** Returns the list of currently registered extensions. */
-  public static List<AsyncResultExtension> registered() {
-    return EXTENSIONS;
-  }
-
   static final class CompletableAsyncResultExtension implements AsyncResultExtension {
     @Override
     public boolean supports(Class<?> result) {

dd-java-agent/agent-ci-visibility/build.gradle

@@ -37,6 +37,7 @@ dependencies {
   testImplementation group: 'org.skyscreamer', name: 'jsonassert', version: '1.5.1'
   testImplementation group: 'org.freemarker', name: 'freemarker', version: '2.3.31'
   testImplementation group: 'org.msgpack', name: 'jackson-dataformat-msgpack', version: '0.9.6'
+  testImplementation libs.bundles.mockito
 }
 
 tasks.named("shadowJar", ShadowJar) {

dd-java-agent/agent-ci-visibility/civisibility-instrumentation-test-fixtures/src/main/groovy/datadog/trace/civisibility/CiVisibilityInstrumentationTest.groovy

@@ -128,9 +128,9 @@ abstract class CiVisibilityInstrumentationTest extends InstrumentationSpecificat
     def metricCollector = Stub(CiVisibilityMetricCollectorImpl)
 
     def sourcePathResolver = Stub(SourcePathResolver)
-    sourcePathResolver.getSourcePath(_ as Class) >> DUMMY_SOURCE_PATH
-    sourcePathResolver.getResourcePath(_ as String) >> {
-      String path -> path
+    sourcePathResolver.getSourcePaths(_ as Class) >> [DUMMY_SOURCE_PATH]
+    sourcePathResolver.getResourcePaths(_ as String) >> {
+      String path -> [path]
     }
 
     def codeowners = Stub(Codeowners)

dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/coverage/ConcurrentCoverageStore.java

@@ -4,7 +4,6 @@
 import datadog.trace.api.civisibility.coverage.CoverageProbes;
 import datadog.trace.api.civisibility.coverage.CoverageStore;
 import datadog.trace.api.civisibility.coverage.TestReport;
-import datadog.trace.civisibility.source.SourceResolutionException;
 import java.util.Collection;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -37,18 +36,13 @@ private T create(Thread thread) {
 
   @Override
   public boolean report(DDTraceId testSessionId, Long testSuiteId, long testSpanId) {
-    try {
-      report = report(testSessionId, testSuiteId, testSpanId, probes.values());
-      return report != null && report.isNotEmpty();
-    } catch (SourceResolutionException e) {
-      return false;
-    }
+    report = report(testSessionId, testSuiteId, testSpanId, probes.values());
+    return report != null && report.isNotEmpty();
   }
 
   @Nullable
   protected abstract TestReport report(
-      DDTraceId testSessionId, Long testSuiteId, long testSpanId, Collection<T> probes)
-      throws SourceResolutionException;
+      DDTraceId testSessionId, Long testSuiteId, long testSpanId, Collection<T> probes);
 
   @Nullable
   @Override

dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/coverage/file/FileCoverageStore.java

@@ -11,7 +11,6 @@
 import datadog.trace.api.civisibility.telemetry.tag.CoverageErrorType;
 import datadog.trace.civisibility.coverage.ConcurrentCoverageStore;
 import datadog.trace.civisibility.source.SourcePathResolver;
-import datadog.trace.civisibility.source.SourceResolutionException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -47,61 +46,54 @@ private FileCoverageStore(
   @Nullable
   @Override
   protected TestReport report(
-      DDTraceId testSessionId, Long testSuiteId, long testSpanId, Collection<FileProbes> probes)
-      throws SourceResolutionException {
-    try {
-      Set<Class<?>> combinedClasses = Collections.newSetFromMap(new IdentityHashMap<>());
-      Collection<String> combinedNonCodeResources = new HashSet<>();
-
-      for (FileProbes probe : probes) {
-        combinedClasses.addAll(probe.getCoveredClasses());
-        combinedNonCodeResources.addAll(probe.getNonCodeResources());
-      }
+      DDTraceId testSessionId, Long testSuiteId, long testSpanId, Collection<FileProbes> probes) {
+    Set<Class<?>> combinedClasses = Collections.newSetFromMap(new IdentityHashMap<>());
+    Collection<String> combinedNonCodeResources = new HashSet<>();
 
-      if (combinedClasses.isEmpty() && combinedNonCodeResources.isEmpty()) {
-        return null;
-      }
+    for (FileProbes probe : probes) {
+      combinedClasses.addAll(probe.getCoveredClasses());
+      combinedNonCodeResources.addAll(probe.getNonCodeResources());
+    }
 
-      Set<String> coveredPaths = set(combinedClasses.size() + combinedNonCodeResources.size());
-      for (Class<?> clazz : combinedClasses) {
-        String sourcePath = sourcePathResolver.getSourcePath(clazz);
-        if (sourcePath == null) {
-          log.debug(
-              "Skipping coverage reporting for {} because source path could not be determined",
-              clazz);
-          metrics.add(CiVisibilityCountMetric.CODE_COVERAGE_ERRORS, 1, CoverageErrorType.PATH);
-          continue;
-        }
-        coveredPaths.add(sourcePath);
-      }
+    if (combinedClasses.isEmpty() && combinedNonCodeResources.isEmpty()) {
+      return null;
+    }
 
-      for (String nonCodeResource : combinedNonCodeResources) {
-        String resourcePath = sourcePathResolver.getResourcePath(nonCodeResource);
-        if (resourcePath == null) {
-          log.debug(
-              "Skipping coverage reporting for {} because resource path could not be determined",
-              nonCodeResource);
-          metrics.add(CiVisibilityCountMetric.CODE_COVERAGE_ERRORS, 1, CoverageErrorType.PATH);
-          continue;
-        }
-        coveredPaths.add(resourcePath);
+    Set<String> coveredPaths = set(combinedClasses.size() + combinedNonCodeResources.size());
+    for (Class<?> clazz : combinedClasses) {
+      Collection<String> sourcePaths = sourcePathResolver.getSourcePaths(clazz);
+      if (sourcePaths.isEmpty()) {
+        log.debug(
+            "Skipping coverage reporting for {} because source path could not be determined",
+            clazz);
+        metrics.add(CiVisibilityCountMetric.CODE_COVERAGE_ERRORS, 1, CoverageErrorType.PATH);
+        continue;
       }
+      coveredPaths.addAll(sourcePaths);
+    }
 
-      List<TestReportFileEntry> fileEntries = new ArrayList<>(coveredPaths.size());
-      for (String path : coveredPaths) {
-        fileEntries.add(new TestReportFileEntry(path, null));
+    for (String nonCodeResource : combinedNonCodeResources) {
+      Collection<String> resourcePaths = sourcePathResolver.getResourcePaths(nonCodeResource);
+      if (resourcePaths.isEmpty()) {
+        log.debug(
+            "Skipping coverage reporting for {} because resource path could not be determined",
+            nonCodeResource);
+        metrics.add(CiVisibilityCountMetric.CODE_COVERAGE_ERRORS, 1, CoverageErrorType.PATH);
+        continue;
       }
+      coveredPaths.addAll(resourcePaths);
+    }
 
-      TestReport report = new TestReport(testSessionId, testSuiteId, testSpanId, fileEntries);
-      metrics.add(
-          CiVisibilityDistributionMetric.CODE_COVERAGE_FILES,
-          report.getTestReportFileEntries().size());
-      return report;
-
-    } catch (Exception e) {
-      metrics.add(CiVisibilityCountMetric.CODE_COVERAGE_ERRORS, 1);
-      throw e;
+    List<TestReportFileEntry> fileEntries = new ArrayList<>(coveredPaths.size());
+    for (String path : coveredPaths) {
+      fileEntries.add(new TestReportFileEntry(path, null));
     }
+
+    TestReport report = new TestReport(testSessionId, testSuiteId, testSpanId, fileEntries);
+    metrics.add(
+        CiVisibilityDistributionMetric.CODE_COVERAGE_FILES,
+        report.getTestReportFileEntries().size());
+    return report;
   }
 
   private static <T> Set<T> set(int size) {