Gradle cache config: bytebuddy

Author: trask

gradle-plugins/src/main/kotlin/io.opentelemetry.instrumentation.muzzle-generation.gradle.kts

@@ -1,7 +1,6 @@
 import io.opentelemetry.javaagent.muzzle.generation.ClasspathByteBuddyPlugin
 import io.opentelemetry.javaagent.muzzle.generation.ClasspathTransformation
-import net.bytebuddy.ClassFileVersion
-import net.bytebuddy.build.gradle.ByteBuddySimpleTask
+import io.opentelemetry.javaagent.muzzle.generation.ConfigurationCacheFriendlyByteBuddyTask
 import net.bytebuddy.build.gradle.Transformation
 
 plugins {
@@ -50,7 +49,7 @@ val languageTasks = LANGUAGES.map { language ->
     return@map null
   }
   val compileTask = tasks.named(compileTaskName)
-  createLanguageTask(compileTask, "byteBuddy${language.replaceFirstChar(Char::titlecase)}")
+  createLanguageTask(compileTask, language)
 }.filterNotNull()
 
 tasks {
@@ -60,29 +59,43 @@ tasks {
 }
 
 fun createLanguageTask(
-  compileTaskProvider: TaskProvider<*>, name: String): TaskProvider<*> {
-  return tasks.register<ByteBuddySimpleTask>(name) {
-    setGroup("Byte Buddy")
-    outputs.cacheIf { true }
-    classFileVersion = ClassFileVersion.JAVA_V8
-    var transformationClassPath = inputClasspath
+  compileTaskProvider: TaskProvider<*>, language: String): TaskProvider<*> {
+  val taskName = "byteBuddy${language.replaceFirstChar { it.uppercase() }}"
+  val mainSourceSet = sourceSets.main.get()
+
+  // Create the input classpath from the existing logic in the main part
+  val inputClasspath = (mainSourceSet.output.resourcesDir?.let { codegen.plus(project.files(it)) }
+    ?: codegen)
+    .plus(mainSourceSet.output.dirs) // needed to support embedding shadowed modules into instrumentation
+    .plus(configurations.runtimeClasspath.get())
+
+  val byteBuddyTask = tasks.register(taskName, ConfigurationCacheFriendlyByteBuddyTask::class.java) {
+    dependsOn(compileTaskProvider, mainSourceSet.processResourcesTaskName)
+
+    transformations.add(createTransformation(inputClasspath, pluginName))
+
+    // Configure the ByteBuddy task properties directly during task creation
     val compileTask = compileTaskProvider.get()
     // this does not work for kotlin as compile task does not extend AbstractCompile
     if (compileTask is AbstractCompile) {
       val classesDirectory = compileTask.destinationDirectory.asFile.get()
-      val rawClassesDirectory: File = File(classesDirectory.parent, "${classesDirectory.name}raw")
-        .absoluteFile
-      dependsOn(compileTask)
+      val rawClassesDirectory = File(classesDirectory.parent, "${classesDirectory.name}raw").absoluteFile
+
+      // Configure the compile task to write to rawClassesDirectory
       compileTask.destinationDirectory.set(rawClassesDirectory)
+
+      // Configure ByteBuddy task properties
       source = rawClassesDirectory
       target = classesDirectory
       classPath = compileTask.classpath.plus(rawClassesDirectory)
-      transformationClassPath = transformationClassPath.plus(files(rawClassesDirectory))
-      dependsOn(compileTask, sourceSet.processResourcesTaskName)
-    }
 
-    transformations.add(createTransformation(transformationClassPath, pluginName))
+      // Clear and set transformations with correct classpath
+      transformations.clear()
+      transformations.add(createTransformation(inputClasspath.plus(files(rawClassesDirectory)), pluginName))
+    }
   }
+
+  return byteBuddyTask
 }
 
 fun createTransformation(classPath: FileCollection, pluginClassName: String): Transformation {

gradle-plugins/src/main/kotlin/io/opentelemetry/javaagent/muzzle/generation/ConfigurationCacheFriendlyByteBuddyTask.kt

@@ -0,0 +1,29 @@
+package io.opentelemetry.javaagent.muzzle.generation
+
+import net.bytebuddy.build.Plugin
+import net.bytebuddy.build.gradle.ByteBuddySimpleTask
+import org.gradle.api.tasks.TaskAction
+import java.io.IOException
+
+/**
+ * Byte Buddy task variant that avoids touching Gradle's Project API from the task action so the
+ * task remains compatible with Gradle configuration cache.
+ */
+open class ConfigurationCacheFriendlyByteBuddyTask : ByteBuddySimpleTask() {
+
+  @TaskAction
+  @Throws(IOException::class)
+  override fun apply() {
+    val sourceDir = source
+    val targetDir = target
+
+    if (sourceDir != targetDir && deleteRecursively(targetDir)) {
+      logger.debug("Deleted all target files in {}", targetDir)
+    }
+
+    doApply(
+      Plugin.Engine.Source.ForFolder(sourceDir),
+      Plugin.Engine.Target.ForFolder(targetDir)
+    )
+  }
+}