Centralize spotless setup as a buildSrc convention plugin.

.gitlab-ci.yml

@@ -407,7 +407,9 @@ spotless:
   stage: tests
   needs: []
   variables:
-    GRADLE_MEMORY_MAX: 6G
+    # Give spotlessCheck more heap and fewer parallel workers — it OOMs on CI otherwise.
+    GRADLE_MEMORY_MAX: 8G
+    GRADLE_WORKERS: 2
   script:
     - ./gradlew --version
     - ./gradlew spotlessCheck $GRADLE_ARGS

build.gradle.kts

@@ -1,4 +1,3 @@
-import com.diffplug.gradle.spotless.SpotlessExtension
 import datadog.gradle.plugin.ci.testAggregate
 
 plugins {
@@ -10,8 +9,8 @@ plugins {
   id("dd-trace-java.dump-hanged-test")
   id("dd-trace-java.config-inversion-linter")
   id("dd-trace-java.ci-jobs")
+  id("dd-trace-java.spotless-conventions")
 
-  id("com.diffplug.spotless") version "8.4.0"
   id("me.champeau.gradle.japicmp") version "0.4.3"
   id("com.github.spotbugs") version "6.5.0"
   id("de.thetaphi.forbiddenapis") version "3.10"
@@ -28,38 +27,6 @@ val isCI = providers.environmentVariable("CI")
 apply(from = rootDir.resolve("gradle/repositories.gradle"))
 apply(from = rootDir.resolve("gradle/ddprof-override.gradle"))
 
-spotless {
-  // only resolve the spotless dependencies once in the build
-  predeclareDeps()
-}
-
-with(extensions["spotlessPredeclare"] as SpotlessExtension) {
-  // these need to align with the types and versions in gradle/spotless.gradle
-  java {
-    removeUnusedImports()
-
-    googleJavaFormat("1.35.0")
-    tableTestFormatter("1.1.1")
-  }
-  groovyGradle {
-    greclipse()
-  }
-  groovy {
-    greclipse()
-  }
-  kotlinGradle {
-    ktlint("1.8.0")
-  }
-  kotlin {
-    ktlint("1.8.0")
-  }
-  scala {
-    // TODO: For some reason Scala format is working correctly with this version only.
-    scalafmt("3.8.6")
-  }
-}
-apply(from = rootDir.resolve("gradle/spotless.gradle"))
-
 val compileTask = tasks.register("compile")
 
 allprojects {

buildSrc/build.gradle.kts

@@ -1,20 +1,43 @@
+import org.gradle.api.attributes.java.TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
+
 plugins {
   `java-gradle-plugin`
   `kotlin-dsl`
   `jvm-test-suite`
-  id("com.diffplug.spotless") version "8.4.0"
 }
 
-// The buildSrc still needs to target Java 8 as build time instrumentation and muzzle plugin
-// allow to schedule workers on different JDK version.
+// Compile with a modern JDK toolchain (21), but keep the emitted bytecode at Java 8.
+// Rationale: the build-time instrumentation and muzzle plugins schedule Gradle workers
+// on different JDK versions, including Java 8, so any class loaded from buildSrc must
+// remain Java 8 compatible.
 java {
+  toolchain {
+    languageVersion = JavaLanguageVersion.of(21)
+  }
+
   sourceCompatibility = JavaVersion.VERSION_1_8
   targetCompatibility = JavaVersion.VERSION_1_8
 }
 
+// Same split for Kotlin: compile on JDK 21 but target the Java 8 bytecode level so the
+// Kotlin output can be loaded by the same Java-8 workers described above.
 kotlin {
+  jvmToolchain(21)
+
   compilerOptions {
-    jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8)
+    jvmTarget.set(JVM_1_8)
+  }
+}
+
+// Advertise Java 17 as the target JVM version when *resolving* dependencies. Several
+// modern Gradle plugins (notably Spotless 8.x) publish only Java 17+ variants via Gradle
+// Module Metadata; without this attribute, resolution fails with "no matching variant"
+// because our targetCompatibility above declares Java 8. This affects dependency
+// resolution only — it does not change the bytecode level we emit, which stays at Java 8.
+configurations.configureEach {
+  if (isCanBeResolved) {
+    attributes.attribute(TARGET_JVM_VERSION_ATTRIBUTE, 17)
   }
 }
 
@@ -63,6 +86,11 @@ gradlePlugin {
       id = "dd-trace-java.instrumentation-naming"
       implementationClass = "datadog.gradle.plugin.naming.InstrumentationNamingPlugin"
     }
+
+    create("spotless-conventions") {
+      id = "dd-trace-java.spotless-conventions"
+      implementationClass = "datadog.gradle.plugin.spotless.SpotlessConventionsPlugin"
+    }
   }
 }
 
@@ -78,6 +106,7 @@ dependencies {
   implementation(gradleApi())
 
   implementation("net.bytebuddy", "byte-buddy-gradle-plugin", "1.18.8")
+  implementation("com.diffplug.spotless:spotless-plugin-gradle:8.5.0")
 
   implementation("org.eclipse.aether", "aether-connector-basic", "1.1.0")
   implementation("org.eclipse.aether", "aether-transport-http", "1.1.0")

buildSrc/call-site-instrumentation-plugin/build.gradle.kts

@@ -1,6 +1,5 @@
 plugins {
   java
-  id("com.diffplug.spotless") version "8.4.0"
   id("com.gradleup.shadow") version "8.3.9"
 }
 
@@ -9,17 +8,6 @@ java {
   targetCompatibility = JavaVersion.VERSION_1_8
 }
 
-spotless {
-  java {
-    toggleOffOn()
-    // set explicit target to workaround https://github.com/diffplug/spotless/issues/1163
-    target("src/**/*.java")
-    // ignore embedded test projects
-    targetExclude("src/test/resources/**")
-    googleJavaFormat("1.35.0")
-  }
-}
-
 apply {
   from("$rootDir/../gradle/repositories.gradle")
 }

buildSrc/src/main/kotlin/datadog/gradle/plugin/spotless/SpotlessConventionsPlugin.kt

@@ -0,0 +1,203 @@
+package datadog.gradle.plugin.spotless
+
+import com.diffplug.gradle.spotless.SpotlessExtension
+import com.diffplug.gradle.spotless.SpotlessExtensionPredeclare
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+
+class SpotlessConventionsPlugin : Plugin<Project> {
+  private companion object {
+    const val GOOGLE_JAVA_FORMAT_VERSION = "1.35.0"
+    const val TABLE_TEST_FORMATTER_VERSION = "1.1.1"
+    const val KTLINT_VERSION = "1.8.0"
+    const val SCALAFMT_VERSION = "3.11.1"
+
+    val KTLINT_EDITOR_CONFIG_OVERRIDE =
+      mapOf(
+        "ktlint_standard_trailing-comma-on-call-site" to "disabled",
+        "ktlint_standard_trailing-comma-on-declaration-site" to "disabled"
+      )
+
+    val EXCLUDED_PROJECTS = setOf(":dd-java-agent:agent-jmxfetch")
+  }
+
+  override fun apply(project: Project) {
+    if (project.path in EXCLUDED_PROJECTS) {
+      return
+    }
+
+    project.pluginManager.apply("com.diffplug.spotless")
+
+    if (project == project.rootProject) {
+      configurePredeclaredDependencies(project)
+      configureRootFormatting(project)
+    } else {
+      configureProjectFormatting(project)
+    }
+  }
+
+  private fun configurePredeclaredDependencies(project: Project) {
+    project.extensions.configure<SpotlessExtensionPredeclare> {
+      java {
+        tableTestFormatter(TABLE_TEST_FORMATTER_VERSION)
+        googleJavaFormat(GOOGLE_JAVA_FORMAT_VERSION)
+      }
+
+      groovyGradle {
+        greclipse()
+      }
+
+      groovy {
+        greclipse()
+      }
+
+      kotlinGradle {
+        ktlint(KTLINT_VERSION)
+      }
+
+      kotlin {
+        ktlint(KTLINT_VERSION)
+      }
+
+      scala {
+        scalafmt(SCALAFMT_VERSION)
+      }
+    }
+  }
+
+  private fun configureRootFormatting(project: Project) {
+    project.extensions.configure<SpotlessExtension> {
+      configureSkipSpotless(project, this)
+
+      val rootExcludes = listOf(
+        "build/**",
+        "buildSrc/build/**",
+        "buildSrc/**/build/**",
+        "test-published-dependencies/**/build/**"
+      )
+
+      kotlinGradle {
+        toggleOffOn()
+        target(
+          "*.gradle.kts",
+          "buildSrc/**/*.gradle.kts",
+          "gradle/**/*.gradle.kts",
+          "test-published-dependencies/**/*.gradle.kts"
+        )
+        targetExclude(rootExcludes)
+        ktlint(KTLINT_VERSION)
+          .editorConfigOverride(KTLINT_EDITOR_CONFIG_OVERRIDE)
+      }
+
+      groovyGradle {
+        toggleOffOn()
+        target(
+          "*.gradle",
+          "buildSrc/**/*.gradle",
+          "gradle/**/*.gradle",
+          "test-published-dependencies/**/*.gradle"
+        )
+        targetExclude(rootExcludes)
+        greclipse().configFile("${project.rootDir}/gradle/enforcement/spotless-groovy.properties")
+      }
+
+      kotlin {
+        toggleOffOn()
+        target("buildSrc/**/*.kt")
+        targetExclude(rootExcludes)
+        ktlint(KTLINT_VERSION)
+          .editorConfigOverride(KTLINT_EDITOR_CONFIG_OVERRIDE)
+      }
+
+      java {
+        toggleOffOn()
+        target("buildSrc/**/*.java", "test-published-dependencies/**/src/**/*.java")
+        targetExclude(rootExcludes)
+        tableTestFormatter(TABLE_TEST_FORMATTER_VERSION)
+        googleJavaFormat(GOOGLE_JAVA_FORMAT_VERSION)
+      }
+
+      format("markdown") {
+        toggleOffOn()
+        target("*.md", ".github/**/*.md", "src/**/*.md", "app*/**/*.md")
+        leadingTabsToSpaces()
+        endWithNewline()
+      }
+
+      format("misc") {
+        toggleOffOn()
+        target(".gitignore", "*.sh", "tooling/*.sh", ".gitlab/*.sh")
+        leadingTabsToSpaces()
+        trimTrailingWhitespace()
+        endWithNewline()
+      }
+    }
+  }
+
+  private fun configureProjectFormatting(project: Project) {
+    project.extensions.configure<SpotlessExtension> {
+      configureSkipSpotless(project, this)
+
+      val commonExcludes = listOf("build/**", "src/test/resources/**")
+
+      kotlinGradle {
+        toggleOffOn()
+        target("*.gradle.kts")
+        ktlint(KTLINT_VERSION)
+          .editorConfigOverride(KTLINT_EDITOR_CONFIG_OVERRIDE)
+      }
+
+      groovyGradle {
+        toggleOffOn()
+        target("*.gradle")
+        greclipse().configFile("${project.rootDir}/gradle/enforcement/spotless-groovy.properties")
+      }
+
+      project.pluginManager.withPlugin("java") {
+        java {
+          toggleOffOn()
+          target("src/**/*.java", "app*/**/*.java")
+          targetExclude(commonExcludes)
+          tableTestFormatter(TABLE_TEST_FORMATTER_VERSION)
+          googleJavaFormat(GOOGLE_JAVA_FORMAT_VERSION)
+        }
+      }
+
+      project.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+        kotlin {
+          toggleOffOn()
+          target("src/**/*.kt", "app*/**/*.kt")
+          targetExclude(commonExcludes)
+          ktlint(KTLINT_VERSION)
+            .editorConfigOverride(KTLINT_EDITOR_CONFIG_OVERRIDE)
+        }
+      }
+
+      project.pluginManager.withPlugin("scala") {
+        scala {
+          toggleOffOn()
+          target("src/**/*.scala", "app*/**/*.scala")
+          targetExclude(commonExcludes)
+          scalafmt(SCALAFMT_VERSION)
+            .configFile("${project.rootDir}/gradle/enforcement/spotless-scalafmt.conf")
+        }
+      }
+
+      project.pluginManager.withPlugin("groovy") {
+        groovy {
+          toggleOffOn()
+          target("src/**/*.groovy", "app*/**/*.groovy")
+          targetExclude(commonExcludes)
+          greclipse().configFile("${project.rootDir}/gradle/enforcement/spotless-groovy.properties")
+        }
+      }
+    }
+  }
+
+  private fun configureSkipSpotless(project: Project, spotless: SpotlessExtension) {
+    if (project.rootProject.hasProperty("skipSpotless")) {
+      spotless.setEnforceCheck(false)
+    }
+  }
+}

buildSrc/src/main/kotlin/dd-trace-java.profiling-ddprof-override.gradle.kts

@@ -1,12 +1,11 @@
-/**
- * Convention plugin for overriding ddprof dependency version with snapshot.
- *
- * When the root project has the property 'ddprofUseSnapshot' set, this plugin:
- * 1. Reads the calculated snapshot version from root project
- * 2. Overrides all ddprof dependencies to use the snapshot version
- *
- * Apply this plugin only to projects that depend on ddprof.
- */
+//
+// Convention plugin for overriding ddprof dependency version with snapshot.
+//
+// When the root project has the property 'ddprofUseSnapshot' set, this plugin:
+// 1. Reads the calculated snapshot version from root project
+// 2. Overrides all ddprof dependencies to use the snapshot version
+//
+// Apply this plugin only to projects that depend on ddprof.
 
 if (rootProject.hasProperty("ddprofUseSnapshot")) {
   val ddprofSnapshotVersion = rootProject.property("ddprofSnapshotVersion").toString()

dd-java-agent/agent-iast/build.gradle

@@ -100,11 +100,6 @@ ext {
 tasks.withType(Test).configureEach {
   jvmArgs += ['-Ddd.iast.enabled=true']
 }
-spotless {
-  java {
-    target 'src/**/*.java'
-  }
-}
 
 jmh {
   jmhVersion = libs.versions.jmh.get()