Merge branch 'master' into alexeyk/groovy-4

# Conflicts:
#	dd-trace-core/src/main/java/datadog/trace/core/CoreTracer.java

Author: AlexeyKuznetsov-DD

…dSrc/src/main/kotlin/CIJobsExtensions.kt …dog/gradle/plugin/ci/CIJobsExtensions.ktbuildSrc/src/main/kotlin/CIJobsExtensions.kt renamed to buildSrc/src/main/kotlin/datadog/gradle/plugin/ci/CIJobsExtensions.kt buildSrc/src/main/kotlin/CIJobsExtensions.kt renamed to buildSrc/src/main/kotlin/datadog/gradle/plugin/ci/CIJobsExtensions.kt

@@ -30,7 +30,7 @@ class VersionSet(versions: Collection<Version>) {
       return resultSet.map { it.version }
     }
 
-    private class ParsedVersion(val version: Version) : Comparable<ParsedVersion> {
+    internal class ParsedVersion(val version: Version) : Comparable<ParsedVersion> {
         companion object {
             private val dotPattern = Regex("\\.")
             private const val VERSION_SHIFT = 12

buildSrc/src/main/kotlin/datadog/gradle/plugin/muzzle/VersionSet.kt

@@ -0,0 +1,27 @@
+package datadog.gradle.plugin.muzzle
+
+import org.eclipse.aether.artifact.Artifact
+import org.eclipse.aether.artifact.DefaultArtifact
+import org.eclipse.aether.resolution.VersionRangeRequest
+import org.gradle.internal.impldep.org.junit.Assert.assertTrue
+import org.junit.jupiter.api.Test
+
+class RangeQueryTest {
+  private val system = MuzzleMavenRepoUtils.newRepositorySystem()
+  private val session = MuzzleMavenRepoUtils.newRepositorySystemSession(system)
+
+  @Test
+  fun `test range request`() {
+    // compile group: 'org.codehaus.groovy', name: 'groovy-all', version: '2.5.0', ext: 'pom'
+    val directiveArtifact: Artifact = DefaultArtifact("org.codehaus.groovy", "groovy-all", "jar", "[2.5.0,2.5.8)")
+    val rangeRequest = VersionRangeRequest().apply {
+      repositories = MuzzleMavenRepoUtils.MUZZLE_REPOS
+      artifact = directiveArtifact
+    }
+
+    // This call makes an actual network request, which may fail if network access is limited.
+    val rangeResult = system.resolveVersionRange(session, rangeRequest)
+
+    assertTrue(rangeResult.versions.size >= 8)
+  }
+}

buildSrc/src/test/groovy/datadog/gradle/plugin/muzzle/RangeQueryTest.groovy

@@ -0,0 +1,102 @@
+package datadog.gradle.plugin.muzzle
+
+import org.eclipse.aether.version.Version
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+class VersionSetTest {
+
+  @Test
+  fun `parse versions properly`() {
+    data class Case(
+      val version: Version,
+      val versionNumber: Long,
+      val ending: String
+    )
+
+    val cases = listOf(
+      Case(ver("1.2.3"), num(1, 2, 3), ""),
+      Case(ver("4.5.6-foo"), num(4, 5, 6), "foo"),
+      Case(ver("7.8.9.foo"), num(7, 8, 9), "foo"),
+      Case(ver("10.11.12.foo-bar"), num(10, 11, 12), "foo-bar"),
+      Case(ver("13.14.foo-bar"), num(13, 14, 0), "foo-bar"),
+      Case(ver("15.foo"), num(15, 0, 0), "foo"),
+      Case(ver("16-foo"), num(16, 0, 0), "foo")
+    )
+
+    for (c in cases) {
+      val parsed = VersionSet.ParsedVersion(c.version)
+      assertEquals(c.versionNumber, parsed.versionNumber, "versionNumber for ${c.version}")
+      assertEquals(c.ending, parsed.ending, "ending for ${c.version}")
+      assertEquals(
+        c.versionNumber shr 12,
+        parsed.majorMinor.toLong(),
+        "majorMinor for ${c.version}"
+      )
+    }
+  }
+
+  @Test
+  fun `select low and high from major minor`() {
+    val versionsCases = listOf(
+      listOf(
+        ver("4.5.6"),
+        ver("1.2.3")
+      ),
+      listOf(
+        ver("1.2.3"),
+        ver("1.2.1"),
+        ver("1.3.0"),
+        ver("1.2.7"),
+        ver("1.4.17"),
+        ver("1.4.1"),
+        ver("1.4.0"),
+        ver("1.4.10")
+      )
+    )
+
+    val expectedCases = listOf(
+      listOf(
+        ver("1.2.3"),
+        ver("4.5.6")
+      ),
+      listOf(
+        ver("1.2.1"),
+        ver("1.2.7"),
+        ver("1.3.0"),
+        ver("1.4.0"),
+        ver("1.4.17")
+      )
+    )
+
+    versionsCases.zip(expectedCases).forEach { (versions, expected) ->
+      val versionSet = VersionSet(versions)
+      assertEquals(expected, versionSet.lowAndHighForMajorMinor)
+    }
+  }
+
+  private fun ver(v: String): Version = TestVersion(v)
+
+  private fun num(major: Int, minor: Int, micro: Int): Long {
+    var result = major.toLong()
+    result = (((result shl 12) + minor) shl 12) + micro
+    return result
+  }
+
+  private class TestVersion(private val v: String) : Version {
+    override fun compareTo(other: Version?): Int {
+      if (other is TestVersion) {
+        return v.compareTo(other.v)
+      }
+
+      return 1
+    }
+
+    override fun equals(other: Any?): Boolean =
+      other is TestVersion && v == other.v
+
+    override fun hashCode(): Int = v.hashCode()
+
+    override fun toString(): String = v
+  }
+}

buildSrc/src/test/groovy/datadog/gradle/plugin/muzzle/VersionSetTest.groovy

@@ -1,5 +1,6 @@
 package datadog.trace.bootstrap.debugger;
 
+import datadog.instrument.asm.Type;
 import datadog.trace.api.Config;
 import datadog.trace.bootstrap.debugger.util.TimeoutChecker;
 import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
@@ -100,7 +101,7 @@ public interface ExceptionDebugger {
   public interface CodeOriginRecorder {
     String captureCodeOrigin(boolean entry);
 
-    String captureCodeOrigin(Method method, boolean entry);
+    String captureCodeOrigin(String typeName, String methodName, String descriptor, boolean entry);
   }
 
   private static volatile ProbeResolver probeResolver;
@@ -506,11 +507,27 @@ public static void captureCodeOrigin(boolean entry) {
     }
   }
 
+  public static void captureCodeOrigin(
+      String typeName, String methodName, String descriptor, boolean entry) {
+    try {
+      CodeOriginRecorder recorder = codeOriginRecorder;
+      if (recorder != null) {
+        recorder.captureCodeOrigin(typeName, methodName, descriptor, entry);
+      }
+    } catch (Exception ex) {
+      LOGGER.debug("Error in captureCodeOrigin: ", ex);
+    }
+  }
+
   public static void captureCodeOrigin(Method method, boolean entry) {
     try {
       CodeOriginRecorder recorder = codeOriginRecorder;
       if (recorder != null) {
-        recorder.captureCodeOrigin(method, entry);
+        recorder.captureCodeOrigin(
+            method.getDeclaringClass().getName(),
+            method.getName(),
+            Type.getMethodDescriptor(method),
+            entry);
       }
     } catch (Exception ex) {
       LOGGER.debug("Error in captureCodeOrigin: ", ex);

buildSrc/src/test/kotlin/datadog/gradle/plugin/muzzle/RangeQueryTest.kt

@@ -5,6 +5,7 @@
 
 import com.datadog.debugger.agent.ConfigurationUpdater;
 import com.datadog.debugger.exception.Fingerprinter;
+import com.datadog.debugger.instrumentation.Types;
 import com.datadog.debugger.probe.CodeOriginProbe;
 import com.datadog.debugger.probe.LogProbe;
 import com.datadog.debugger.probe.LogProbe.Builder;
@@ -20,7 +21,6 @@
 import datadog.trace.bootstrap.instrumentation.api.AgentTracer;
 import datadog.trace.util.AgentTaskScheduler;
 import datadog.trace.util.stacktrace.StackWalkerFactory;
-import java.lang.reflect.Method;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
@@ -82,11 +82,13 @@ public String captureCodeOrigin(boolean entry) {
   }
 
   @Override
-  public String captureCodeOrigin(Method method, boolean entry) {
-    String fingerprint = method.toString();
+  public String captureCodeOrigin(
+      String typeName, String methodName, String descriptor, boolean entry) {
+    String fingerprint = typeName + "." + methodName + descriptor;
     CodeOriginProbe probe = probesByFingerprint.get(fingerprint);
     if (probe == null) {
-      probe = createProbe(fingerprint, entry, Where.of(method));
+      String signature = Types.descriptorToSignature(descriptor);
+      probe = createProbe(fingerprint, entry, Where.of(typeName, methodName, signature));
       LOG.debug("Creating probe for method {}", fingerprint);
     }
     return probe.getId();

buildSrc/src/test/kotlin/datadog/gradle/plugin/muzzle/VersionSetTest.kt

@@ -1,22 +1,18 @@
 package com.datadog.debugger.probe;
 
-import static java.util.Arrays.stream;
-
 import com.datadog.debugger.agent.Generated;
 import com.datadog.debugger.instrumentation.Types;
 import com.datadog.debugger.util.ClassFileLines;
 import com.squareup.moshi.JsonAdapter;
 import com.squareup.moshi.JsonReader;
 import com.squareup.moshi.JsonWriter;
 import java.io.IOException;
-import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-import java.util.stream.Collectors;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.tree.MethodNode;
 
@@ -50,13 +46,8 @@ public static Where of(String typeName, String methodName, String signature, Str
     return new Where(typeName, methodName, signature, lines, null);
   }
 
-  public static Where of(Method method) {
-    return of(
-        method.getDeclaringClass().getName(),
-        method.getName(),
-        stream(method.getParameterTypes())
-            .map(Class::getTypeName)
-            .collect(Collectors.joining(", ", "(", ")")));
+  public static Where of(String typeName, String methodName, String signature) {
+    return new Where(typeName, methodName, signature, (SourceLine[]) null, null);
   }
 
   protected static SourceLine[] sourceLines(String[] defs) {