Merge remote-tracking branch 'origin/master' into alexeyk/groovy-4

Author: AlexeyKuznetsov-DD

.github/CODEOWNERS

@@ -51,9 +51,9 @@
 /dd-java-agent/appsec/appsec-test-fixtures/                     @DataDog/asm-java
 /dd-java-agent/instrumentation/*iast*                           @DataDog/asm-java
 /dd-java-agent/instrumentation/*appsec*                         @DataDog/asm-java
-/dd-java-agent/instrumentation/json/                            @DataDog/asm-java
-/dd-java-agent/instrumentation/snakeyaml/                       @DataDog/asm-java
-/dd-java-agent/instrumentation/velocity/                        @DataDog/asm-java
+/dd-java-agent/instrumentation/org-json-20230227/               @DataDog/asm-java
+/dd-java-agent/instrumentation/snakeyaml-1.33/                  @DataDog/asm-java
+/dd-java-agent/instrumentation/velocity-1.5/                    @DataDog/asm-java
 /dd-java-agent/instrumentation/freemarker/                      @DataDog/asm-java
 /dd-smoke-tests/iast-util/                                      @DataDog/asm-java
 /dd-smoke-tests/spring-security/                                @DataDog/asm-java
@@ -77,18 +77,17 @@
 
 # @DataDog/ci-app-libraries-java
 /dd-java-agent/agent-ci-visibility/                 @DataDog/ci-app-libraries-java
-/dd-java-agent/instrumentation/cucumber/            @DataDog/ci-app-libraries-java
-/dd-java-agent/instrumentation/jacoco/              @DataDog/ci-app-libraries-java
+/dd-java-agent/instrumentation/cucumber-5.4/        @DataDog/ci-app-libraries-java
+/dd-java-agent/instrumentation/jacoco-0.8.9/        @DataDog/ci-app-libraries-java
 /dd-java-agent/instrumentation/junit                @DataDog/ci-app-libraries-java
 /dd-java-agent/instrumentation/karate/              @DataDog/ci-app-libraries-java
-/dd-java-agent/instrumentation/scalatest/           @DataDog/ci-app-libraries-java
+/dd-java-agent/instrumentation/scalatest-3.0.8/     @DataDog/ci-app-libraries-java
 /dd-java-agent/instrumentation/selenium/            @DataDog/ci-app-libraries-java
 /dd-java-agent/instrumentation/testng/              @DataDog/ci-app-libraries-java
 /dd-java-agent/instrumentation/gradle/              @DataDog/ci-app-libraries-java
 /dd-java-agent/instrumentation/gradle-testing/      @DataDog/ci-app-libraries-java
 /dd-java-agent/instrumentation/maven                @DataDog/ci-app-libraries-java
-/dd-java-agent/instrumentation/maven-surefire/      @DataDog/ci-app-libraries-java
-/dd-java-agent/instrumentation/weaver/              @DataDog/ci-app-libraries-java
+/dd-java-agent/instrumentation/weaver-0.9/          @DataDog/ci-app-libraries-java
 /dd-smoke-tests/gradle/                             @DataDog/ci-app-libraries-java
 /dd-smoke-tests/junit-console/                      @DataDog/ci-app-libraries-java
 /dd-smoke-tests/maven/                              @DataDog/ci-app-libraries-java

.gitlab-ci.yml

@@ -117,6 +117,21 @@ default:
   - .gitlab/cgroup-info.sh
   - gitlab_section_end "cgroup-info"
 
+.container_info: &container_info
+  - |
+    # Containers and processes are limited to a 1-hour window, and expire after 36 hours
+    if [ -n "$CI_JOB_STARTED_AT" ]; then
+      FROM_EPOCH_MS=$(date -d "$CI_JOB_STARTED_AT" +%s)000
+      TO_EPOCH_MS=$((FROM_EPOCH_MS + 3600000))
+      TIME_PARAMS="from_ts=${FROM_EPOCH_MS}&to_ts=${TO_EPOCH_MS}&"
+    else
+      TIME_PARAMS=""
+    fi
+
+    echo -e "${TEXT_BOLD}${TEXT_YELLOW}Runner dashboard, these are live (limited to a 1-hour window, and expire after 36 hours)${TEXT_CLEAR}"
+    echo -e "${TEXT_BOLD}${TEXT_YELLOW}   Containers:${TEXT_CLEAR} https://app.datadoghq.com/containers?${TIME_PARAMS}query=image_name%3A%2A%2Fdatadog%2Fdd-trace-java-docker-build%20AND%20pod_name%3A${POD_NAME}&live=false"
+    echo -e "${TEXT_BOLD}${TEXT_YELLOW}   Processes:${TEXT_CLEAR} https://app.datadoghq.com/process?${TIME_PARAMS}query=image_name%3A%2A%2Fdatadog%2Fdd-trace-java-docker-build%20AND%20pod_name%3A${POD_NAME}&live=false"
+
 .gitlab_base_ref_params: &gitlab_base_ref_params
   - |
     export GIT_BASE_REF=$(.gitlab/find-gh-base-ref.sh)
@@ -165,6 +180,7 @@ default:
       unprotect: true
   before_script:
     - source .gitlab/gitlab-utils.sh
+    - *container_info
     # Akka token added to SSM from https://account.akka.io/token
     - export ORG_GRADLE_PROJECT_akkaRepositoryToken=$(aws ssm get-parameter --region us-east-1 --name ci.dd-trace-java.akka_repo_token --with-decryption --query "Parameter.Value" --out text)
     - export ORG_GRADLE_PROJECT_mavenRepositoryProxy=$MAVEN_REPOSITORY_PROXY
@@ -195,6 +211,7 @@ default:
     - gitlab_section_end "gradle-dance"
   after_script:
     - *cgroup_info
+    - *container_info
 
 # Check and fail early if maven central credentials are incorrect. When a new token is generated
 # on the central publisher portal, it invalidates the old one. This check prevents going further.
@@ -419,6 +436,7 @@ test_published_artifacts:
     - ./gradlew --version
     - ./gradlew $GRADLE_TARGET -x spotlessCheck $GRADLE_PARAMS -PskipTests -PrunBuildSrcTests -Pslot=$CI_NODE_INDEX/$CI_NODE_TOTAL $GRADLE_ARGS
   after_script:
+    - *container_info
     - *cgroup_info
     - source .gitlab/gitlab-utils.sh
     - gitlab_section_start "collect-reports" "Collecting reports"
@@ -487,6 +505,7 @@ muzzle:
     - ./gradlew --version
     - ./gradlew :runMuzzle -Pslot=$CI_NODE_INDEX/$CI_NODE_TOTAL $GRADLE_ARGS
   after_script:
+    - *container_info
     - *cgroup_info
     - source .gitlab/gitlab-utils.sh
     - gitlab_section_start "collect-reports" "Collecting reports"
@@ -509,6 +528,7 @@ muzzle-dep-report:
     - ./gradlew --version
     - ./gradlew generateMuzzleReport muzzleInstrumentationReport $GRADLE_ARGS
   after_script:
+    - *container_info
     - *cgroup_info
     - .gitlab/collect_muzzle_deps.sh
   artifacts:
@@ -571,6 +591,7 @@ muzzle-dep-report:
   after_script:
     - *restore_pretest_env
     - *set_datadog_api_keys
+    - *container_info
     - *cgroup_info
     - source .gitlab/gitlab-utils.sh
     - gitlab_section_start "collect-reports" "Collecting reports"

build.gradle.kts

@@ -12,6 +12,7 @@ plugins {
   id("dd-trace-java.ci-jobs")
 
   id("com.diffplug.spotless") version "8.1.0"
+  id("me.champeau.gradle.japicmp") version "0.4.3"
   id("com.github.spotbugs") version "6.4.7"
   id("de.thetaphi.forbiddenapis") version "3.10"
   id("io.github.gradle-nexus.publish-plugin") version "2.0.0"
@@ -156,3 +157,29 @@ testAggregate(
     ":dd-java-agent:agent-debugger"
   )
 )
+
+// JApiCmp configuration example
+// Usage: ./gradlew japicmp -Partifact=groupId:artifactId -Pbaseline=1.0.0 -Ptarget=2.0.0
+tasks.register<me.champeau.gradle.japicmp.JapicmpTask>("japicmp") {
+  val artifact = providers.gradleProperty("artifact").orNull
+  val baseline = providers.gradleProperty("baseline").orNull
+  val target = providers.gradleProperty("target").orNull
+
+  if (artifact != null && baseline != null && target != null) {
+    oldClasspath.from(
+      configurations.detachedConfiguration(
+        dependencies.create("$artifact:$baseline")
+      )
+    )
+    newClasspath.from(
+      configurations.detachedConfiguration(
+        dependencies.create("$artifact:$target")
+      )
+    )
+    onlyModified.set(true)
+    failOnModification.set(false)
+    ignoreMissingClasses.set(true)
+    txtOutputFile.set(layout.buildDirectory.file("reports/japicmp.txt"))
+    htmlOutputFile.set(layout.buildDirectory.file("reports/japicmp.html"))
+  }
+}

buildSrc/build.gradle.kts

@@ -47,6 +47,11 @@ gradlePlugin {
       id = "dd-trace-java.config-inversion-linter"
       implementationClass = "datadog.gradle.plugin.config.ConfigInversionLinter"
     }
+
+    create("instrumentation-naming") {
+      id = "dd-trace-java.instrumentation-naming"
+      implementationClass = "datadog.gradle.plugin.naming.InstrumentationNamingPlugin"
+    }
   }
 }
 

buildSrc/src/main/kotlin/datadog/gradle/plugin/config/ConfigInversionLinter.kt

@@ -83,7 +83,7 @@ private fun registerLogEnvVarUsages(target: Project, extension: SupportedTracerC
       include("**/src/main/java/**/*.java")
       exclude("**/build/**", "**/dd-smoke-tests/**")
       // Undertow uses DD_UNDERTOW_CONTINUATION as a legacy key to store an AgentScope. It is not related to an environment variable
-      exclude("dd-java-agent/instrumentation/undertow/src/main/java/datadog/trace/instrumentation/undertow/UndertowDecorator.java")
+      exclude("dd-java-agent/instrumentation/undertow/undertow-common/src/main/java/datadog/trace/instrumentation/undertow/UndertowDecorator.java")
     }
     inputs.files(javaFiles)
     outputs.upToDateWhen { true }

buildSrc/src/main/kotlin/datadog/gradle/plugin/naming/InstrumentationNamingExtension.kt

@@ -0,0 +1,43 @@
+package datadog.gradle.plugin.naming
+
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.SetProperty
+
+/**
+ * Extension for configuring instrumentation naming convention checks.
+ *
+ * Example usage:
+ * ```
+ * instrumentationNaming {
+ *   instrumentationsDir.set(file("dd-java-agent/instrumentation"))
+ *   exclusions.set(setOf("http-url-connection", "sslsocket"))
+ *   suffixes.set(setOf("-common", "-stubs"))
+ * }
+ * ```
+ */
+abstract class InstrumentationNamingExtension {
+  /**
+   * The directory containing instrumentation modules.
+   * Defaults to "dd-java-agent/instrumentation".
+   */
+  abstract val instrumentationsDir: Property<String>
+
+  /**
+   * Set of module names to exclude from naming convention checks.
+   * These modules will not be validated against the naming rules.
+   */
+  abstract val exclusions: SetProperty<String>
+
+  /**
+   * Set of allowed suffixes for module names (e.g., "-common", "-stubs").
+   * Module names must end with either one of these suffixes or a version number.
+   * Defaults to ["-common", "-stubs"].
+   */
+  abstract val suffixes: SetProperty<String>
+
+  init {
+    instrumentationsDir.convention("dd-java-agent/instrumentation")
+    exclusions.convention(emptySet())
+    suffixes.convention(setOf("-common", "-stubs"))
+  }
+}

buildSrc/src/main/kotlin/datadog/gradle/plugin/naming/InstrumentationNamingPlugin.kt

@@ -0,0 +1,184 @@
+package datadog.gradle.plugin.naming
+
+import org.gradle.api.GradleException
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.create
+import java.io.File
+
+/**
+ * Plugin that validates naming conventions for instrumentation modules.
+ *
+ * Rules:
+ * 1. Module name must end with a version (e.g., "2.0", "3.1") OR end with "-common"
+ * 2. Module name must include the parent directory name
+ *    (e.g., "couchbase-2.0" must contain "couchbase" which is the parent directory name)
+ *
+ * Apply this plugin:
+ * ```
+ * plugins {
+ *   id("dd-trace-java.instrumentation-naming")
+ * }
+ * ```
+ */
+class InstrumentationNamingPlugin : Plugin<Project> {
+  private val versionPattern : Regex = Regex("""\d+\.\d+(\.\d+)?$""")
+
+  override fun apply(target: Project) {
+    val extension = target.extensions.create<InstrumentationNamingExtension>("instrumentationNaming")
+
+    target.tasks.register("checkInstrumentationNaming") {
+      group = "verification"
+      description = "Validates naming conventions for instrumentation modules"
+
+      doLast {
+        val instrumentationsDir = target.rootProject.file(extension.instrumentationsDir)
+        val exclusions = extension.exclusions.get()
+        val suffixes = extension.suffixes.get()
+
+        if (!instrumentationsDir.exists() || !instrumentationsDir.isDirectory) {
+          throw GradleException(
+            "Instrumentations directory not found: ${instrumentationsDir.absolutePath}"
+          )
+        }
+
+        val violations = validateInstrumentations(instrumentationsDir, exclusions, suffixes)
+
+        if (violations.isNotEmpty()) {
+          val suffixesStr = suffixes.joinToString("', '", "'", "'")
+          val errorMessage = buildString {
+            appendLine("""
+            
+            Instrumentation naming convention violations found:
+            
+            """.trimIndent())
+            violations.forEach { violation ->
+              appendLine("""
+                • ${violation.path}
+                  ${violation.message}
+              """.trimIndent())
+            }
+            append("""
+              Naming rules:
+                1. Module name must end with a version (e.g., '2.0', '3.1') OR one of: $suffixesStr
+                2. Module name must include the parent directory name
+                   Example: 'couchbase/couchbase-2.0' ✓ (contains 'couchbase')
+
+              To exclude specific modules or customize suffixes, configure the plugin:
+                instrumentationNaming {
+                  exclusions.set(setOf("module-name"))
+                  suffixes.set(setOf("-common", "-stubs"))
+                }
+              """.trimIndent())
+          }
+          throw GradleException(errorMessage)
+        } else {
+          target.logger.lifecycle("✓ All instrumentation modules follow naming conventions")
+        }
+      }
+    }
+  }
+
+  private fun validateInstrumentations(
+    instrumentationsDir: File,
+    exclusions: Set<String>,
+    suffixes: Set<String>
+  ): List<NamingViolation> {
+    val violations = mutableListOf<NamingViolation>()
+
+    fun hasBuildFile(dir: File): Boolean = dir.listFiles()?.any {
+      it.name == "build.gradle" || it.name == "build.gradle.kts"
+    } ?: false
+
+    fun traverseModules(currentDir: File, parentName: String?) {
+      currentDir.listFiles { file -> file.isDirectory }?.forEach childLoop@{ childDir ->
+        val moduleName = childDir.name
+
+        // Skip build directories and other non-instrumentation directories
+        if (moduleName in setOf("build", "src", ".gradle")) {
+          return@childLoop
+        }
+
+        val childHasBuildFile = hasBuildFile(childDir)
+        val nestedModules = childDir.listFiles { file -> file.isDirectory }?.filter { hasBuildFile(it) } ?: emptyList()
+
+        if (childHasBuildFile && moduleName !in exclusions) {
+          val relativePath = childDir.relativeTo(instrumentationsDir).path
+          if (parentName == null && nestedModules.isEmpty()) {
+            validateLeafModuleName(moduleName, relativePath, suffixes)?.let { violations.add(it) }
+          } else if (parentName != null) {
+            violations.addAll(validateModuleName(moduleName, parentName, relativePath, suffixes))
+          }
+        }
+
+        // Continue traversing to validate deeply nested modules
+        if (nestedModules.isNotEmpty() || !childHasBuildFile) {
+          traverseModules(childDir, moduleName)
+        }
+      }
+    }
+
+    traverseModules(instrumentationsDir, null)
+
+    return violations
+  }
+
+  private fun validateModuleName(
+    moduleName: String,
+    parentName: String,
+    relativePath: String,
+    suffixes: Set<String>
+  ): List<NamingViolation> {
+    // Rule 1: Module name must end with version pattern or one of the configured suffixes
+    validateVersionOrSuffix(moduleName, relativePath, suffixes)?.let { return listOf(it) }
+
+    // Rule 2: Module name must contain parent directory name
+    if (!moduleName.contains(parentName, ignoreCase = true)) {
+      return listOf(NamingViolation(
+        relativePath,
+        "Module name '$moduleName' should contain parent directory name '$parentName'"
+      ))
+    }
+
+    return emptyList()
+  }
+
+  /**
+   * Validates naming for leaf modules (modules at the top level with no parent grouping).
+   * These only need to check the version/suffix requirement.
+   */
+  private fun validateLeafModuleName(
+    moduleName: String,
+    relativePath: String,
+    suffixes: Set<String>
+  ): NamingViolation? {
+    return validateVersionOrSuffix(moduleName, relativePath, suffixes)
+  }
+
+  /**
+   * Validates that a module name ends with either a version or one of the configured suffixes.
+   */
+  private fun validateVersionOrSuffix(
+    moduleName: String,
+    relativePath: String,
+    suffixes: Set<String>
+  ): NamingViolation? {
+    val endsWithSuffix = suffixes.any { moduleName.endsWith(it) }
+    val endsWithVersion = versionPattern.containsMatchIn(moduleName)
+
+    if (!endsWithVersion && !endsWithSuffix) {
+      val suffixesStr = suffixes.joinToString("', '", "'", "'")
+      return NamingViolation(
+        relativePath,
+        "Module name '$moduleName' must end with a version (e.g., '2.0', '3.1.0') or one of: $suffixesStr"
+      )
+    }
+
+    return null
+  }
+
+  private data class NamingViolation(
+    val path: String,
+    val message: String
+  )
+}