make suffixes configurable

Author: amarziali

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

@@ -11,6 +11,7 @@ import org.gradle.api.provider.Property
  * instrumentationNaming {
  *   instrumentationsDir.set(file("dd-java-agent/instrumentation"))
  *   exclusions.set(listOf("http-url-connection", "sslsocket"))
+ *   suffixes.set(listOf("-common", "-stubs""))
  * }
  * ```
  */
@@ -27,8 +28,16 @@ abstract class InstrumentationNamingExtension {
    */
   abstract val exclusions: ListProperty<String>
 
+  /**
+   * List 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: ListProperty<String>
+
   init {
     instrumentationsDir.convention("dd-java-agent/instrumentation")
     exclusions.convention(emptyList())
+    suffixes.convention(listOf("-common", "-stubs"))
   }
 }

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

@@ -36,16 +36,18 @@ class InstrumentationNamingPlugin : Plugin<Project> {
       doLast {
         val instrumentationsDir = target.rootProject.file(extension.instrumentationsDir.get())
         val exclusions = extension.exclusions.get().toSet()
+        val suffixes = extension.suffixes.get()
 
         if (!instrumentationsDir.exists() || !instrumentationsDir.isDirectory) {
           throw GradleException(
             "Instrumentations directory not found: ${instrumentationsDir.absolutePath}"
           )
         }
 
-        val violations = validateInstrumentations(instrumentationsDir, exclusions)
+        val violations = validateInstrumentations(instrumentationsDir, exclusions, suffixes)
 
         if (violations.isNotEmpty()) {
+          val suffixesStr = suffixes.joinToString("', '", "'", "'")
           val errorMessage = buildString {
             appendLine("\nInstrumentation naming convention violations found:")
             appendLine()
@@ -55,13 +57,14 @@ class InstrumentationNamingPlugin : Plugin<Project> {
               appendLine()
             }
             appendLine("Naming rules:")
-            appendLine("  1. Module name must end with a version (e.g., '2.0', '3.1') OR end with '-common'")
+            appendLine("  1. Module name must end with a version (e.g., '2.0', '3.1') OR one of: $suffixesStr")
             appendLine("  2. Module name must include the parent directory name")
             appendLine("     Example: 'couchbase/couchbase-2.0' ✓ (contains 'couchbase')")
             appendLine()
-            appendLine("To exclude specific modules, configure the plugin:")
+            appendLine("To exclude specific modules or customize suffixes, configure the plugin:")
             appendLine("  instrumentationNaming {")
             appendLine("    exclusions.set(listOf(\"module-name\"))")
+            appendLine("    suffixes.set(listOf(\"-common\", \"-stubs\"))")
             appendLine("  }")
           }
           throw GradleException(errorMessage)
@@ -74,7 +77,8 @@ class InstrumentationNamingPlugin : Plugin<Project> {
 
   private fun validateInstrumentations(
     instrumentationsDir: File,
-    exclusions: Set<String>
+    exclusions: Set<String>,
+    suffixes: List<String>
   ): List<NamingViolation> {
     val violations = mutableListOf<NamingViolation>()
 
@@ -96,7 +100,7 @@ class InstrumentationNamingPlugin : Plugin<Project> {
       if (hasBuildFile) {
         // This is a leaf module, validate only the version/common suffix requirement
         if (parentName !in exclusions) {
-          validateLeafModuleName(parentName, parentDir.relativeTo(instrumentationsDir).path)?.let {
+          validateLeafModuleName(parentName, parentDir.relativeTo(instrumentationsDir).path, suffixes)?.let {
             violations.add(it)
           }
         }
@@ -116,7 +120,7 @@ class InstrumentationNamingPlugin : Plugin<Project> {
           } ?: false
 
           if (hasModuleBuildFile && moduleName !in exclusions) {
-            validateModuleName(moduleName, parentName, moduleDir.relativeTo(instrumentationsDir).path)?.let {
+            validateModuleName(moduleName, parentName, moduleDir.relativeTo(instrumentationsDir).path, suffixes)?.let {
               violations.add(it)
             }
           }
@@ -130,21 +134,13 @@ class InstrumentationNamingPlugin : Plugin<Project> {
   private fun validateModuleName(
     moduleName: String,
     parentName: String,
-    relativePath: String
+    relativePath: String,
+    suffixes: List<String>
   ): NamingViolation? {
-    // Rule 1: Module name must end with version pattern (X.Y, X.Y.Z, etc.) or "-common"
-    val endsWithCommon = moduleName.endsWith("-common")
-    val endsWithVersion = versionPattern.containsMatchIn(moduleName)
-
-    if (!endsWithVersion && !endsWithCommon) {
-      return NamingViolation(
-        relativePath,
-        "Module name '$moduleName' must end with a version (e.g., '2.0', '3.1.0') or '-common'"
-      )
-    }
+    // Rule 1: Module name must end with version pattern or one of the configured suffixes
+    validateVersionOrSuffix(moduleName, relativePath, suffixes)?.let { return it }
 
     // Rule 2: Module name must contain parent directory name
-    // Extract the base name (without version or -common suffix)
     if (!moduleName.contains(parentName, ignoreCase = true)) {
       return NamingViolation(
         relativePath,
@@ -157,20 +153,32 @@ class InstrumentationNamingPlugin : Plugin<Project> {
 
   /**
    * Validates naming for leaf modules (modules at the top level with no parent grouping).
-   * These only need to check the version/common suffix requirement.
+   * These only need to check the version/suffix requirement.
    */
   private fun validateLeafModuleName(
     moduleName: String,
-    relativePath: String
+    relativePath: String,
+    suffixes: List<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: List<String>
   ): NamingViolation? {
-    // Rule: Module name must end with version pattern (X.Y, X.Y.Z, etc.) or "-common"
-    val endsWithCommon = moduleName.endsWith("-common")
+    val endsWithSuffix = suffixes.any { moduleName.endsWith(it) }
     val endsWithVersion = versionPattern.containsMatchIn(moduleName)
 
-    if (!endsWithVersion && !endsWithCommon) {
+    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 '-common'"
+        "Module name '$moduleName' must end with a version (e.g., '2.0', '3.1.0') or one of: $suffixesStr"
       )
     }
 

buildSrc/src/main/kotlin/datadog/gradle/plugin/naming/README.md

@@ -6,9 +6,9 @@ A Gradle plugin that validates naming conventions for instrumentation modules un
 
 The plugin enforces the following rules:
 
-1. **Version or Common suffix**: Module names must end with either:
+1. **Version or suffix**: Module names must end with either:
    - A version number (e.g., `2.0`, `3.1`, `4.0.5`)
-   - The suffix `-common`
+   - One of the configured suffixes (default: `-common`, `-stubs`)
 
 2. **Parent directory inclusion**: Module names must include the parent directory name
    - Example: `couchbase/couchbase-2.0` ✓ (module name contains "couchbase")
@@ -47,22 +47,29 @@ instrumentationNaming {
     "sslsocket",
     "classloading"
   ))
+
+  // Optional: configure allowed suffixes (default: ["-common", "-stubs"])
+  suffixes.set(listOf(
+    "-common",
+    "-stubs",
+    "-utils"
+  ))
 }
 ```
 
 ## Examples
 
 ### Valid module names:
-- `couchbase/couchbase-2.0` ✓
-- `couchbase/couchbase-2.6` ✓
-- `couchbase/couchbase-3.1` ✓
-- `kafka/kafka-common` ✓
-- `apache-httpclient/apache-httpclient-4.0` ✓
+- `couchbase/couchbase-2.0` ✓ (ends with version)
+- `couchbase/couchbase-2.6` ✓ (ends with version)
+- `couchbase/couchbase-3.1` ✓ (ends with version)
+- `kafka/kafka-common` ✓ (ends with -common suffix)
+- `apache-httpclient/apache-httpclient-4.0` ✓ (ends with version)
 
 ### Invalid module names:
 - `couchbase/foo-2.0` ✗ (doesn't contain parent name "couchbase")
-- `kafka/kafka` ✗ (missing version or -common suffix)
-- `kafka/kafka-latest` ✗ (not a valid version number)
+- `kafka/kafka` ✗ (missing version or allowed suffix)
+- `kafka/kafka-latest` ✗ (not a valid version number or allowed suffix)
 
 ## Integration with CI