Upgrade OTEL to 1.3.1

build.gradle.kts

@@ -32,10 +32,10 @@ subprojects {
     description = "Hypertrace OpenTelemetry Javaagent"
 
     extra.set("versions", mapOf(
-            "opentelemetry" to "1.2.0",
-            "opentelemetry_java_agent" to "1.2.0-alpha",
-            "opentelemetry_java_agent_all" to "1.2.0",
-            "byte_buddy" to "1.10.18",
+            "opentelemetry" to "1.3.0",
+            "opentelemetry_java_agent" to "1.3.1-alpha",
+            "opentelemetry_java_agent_all" to "1.3.1",
+            "byte_buddy" to "1.11.2",
                 "slf4j" to "1.7.30"
     ))
 

buildSrc/build.gradle.kts

@@ -14,19 +14,25 @@ gradlePlugin {
       id = "io.opentelemetry.instrumentation.auto-instrumentation"
       implementationClass = "io.opentelemetry.instrumentation.gradle.AutoInstrumentationPlugin"
     }
+    create("open-telemetry-un-shade-plugin") {
+      id = "io.opentelemetry.instrumentation.un-shade"
+      implementationClass = "io.opentelemetry.instrumentation.gradle.OpenTelemetryUnShadePlugin"
+    }
   }
 }
 
 repositories {
   mavenLocal()
   jcenter()
+  gradlePluginPortal()
   mavenCentral()
 }
 
 dependencies {
   implementation(gradleApi())
   implementation(localGroovy())
 
+  implementation("com.github.jengelman.gradle.plugins:shadow:6.0.0")
   implementation("org.eclipse.aether", "aether-connector-basic", "1.1.0")
   implementation("org.eclipse.aether", "aether-transport-http", "1.1.0")
   implementation("org.apache.maven", "maven-aether-provider", "3.3.9")
@@ -35,7 +41,7 @@ dependencies {
   implementation("org.ow2.asm", "asm", "7.0-beta")
   implementation("org.ow2.asm", "asm-tree", "7.0-beta")
   implementation("org.apache.httpcomponents:httpclient:4.5.10")
-  implementation("net.bytebuddy:byte-buddy-gradle-plugin:1.10.18")
+  implementation("net.bytebuddy:byte-buddy-gradle-plugin:1.11.2")
 
   testImplementation("org.spockframework", "spock-core", "1.3-groovy-2.5")
   testImplementation("org.codehaus.groovy", "groovy-all", "2.5.8")

buildSrc/src/main/java/io/opentelemetry/instrumentation/gradle/AutoInstrumentationPlugin.java

@@ -7,11 +7,18 @@
 
 import java.io.File;
 import java.util.Arrays;
+import java.util.Map;
+import java.util.Objects;
+import org.gradle.api.Action;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.artifacts.Dependency;
+import org.gradle.api.artifacts.dsl.DependencyHandler;
+import org.gradle.api.attributes.AttributeContainer;
+import org.gradle.api.attributes.LibraryElements;
 import org.gradle.api.plugins.JavaLibraryPlugin;
+import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.tasks.Internal;
 import org.gradle.api.tasks.testing.Test;
 import org.gradle.process.CommandLineArgumentProvider;
@@ -27,6 +34,7 @@ public class AutoInstrumentationPlugin implements Plugin<Project> {
   public void apply(Project project) {
     project.getPlugins().apply(JavaLibraryPlugin.class);
     createLibraryConfiguration(project);
+    addDependencies(project);
     project
         .getTasks()
         .withType(
@@ -43,6 +51,40 @@ public void apply(Project project) {
             });
   }
 
+  private void addDependencies(Project project) {
+    DependencyHandler dependencies = project.getDependencies();
+    @SuppressWarnings("unchecked") final Map<String, String> versions = Objects.requireNonNull(
+        (Map<String, String>) project.getExtensions().getExtraProperties().get("versions"));
+
+    dependencies.add("implementation", "org.slf4j:slf4j-api:1.7.30");
+    dependencies.add("compileOnly", "com.google.auto.service:auto-service-annotations:1.0");
+    dependencies.add("annotationProcessor", "com.google.auto.service:auto-service:1.0");
+    dependencies.add("implementation", "net.bytebuddy:byte-buddy:" + versions.get("byte_buddy"));
+    dependencies.add("implementation",
+        "io.opentelemetry:opentelemetry-api:" + versions.get("opentelemetry"));
+    dependencies.add("implementation",
+        "io.opentelemetry.javaagent:opentelemetry-javaagent-tooling:" + versions
+            .get("opentelemetry_java_agent"));
+    dependencies.add("implementation",
+        "io.opentelemetry.javaagent:opentelemetry-javaagent-extension-api:" + versions
+            .get("opentelemetry_java_agent"));
+    dependencies.add("implementation",
+        "io.opentelemetry.javaagent:opentelemetry-javaagent-api:" + versions
+            .get("opentelemetry_java_agent"));
+    dependencies.add("implementation",
+        "io.opentelemetry.instrumentation:opentelemetry-instrumentation-api:" + versions
+            .get("opentelemetry_java_agent"));
+
+    dependencies.add("implementation", dependencies.project(Map.of("path", ":javaagent-core")));
+    dependencies.add("implementation", dependencies.project(Map.of("path", ":filter-api")));
+
+    project.getConfigurations().named(JavaPlugin.COMPILE_CLASSPATH_CONFIGURATION_NAME).configure(
+        files -> files.attributes(attributeContainer -> attributeContainer.attribute(
+            LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE,
+            project.getObjects().named(LibraryElements.class, LibraryElements.JAR))));
+
+  }
+
   /**
    * Creates a custom dependency configuration called {@code library} inspired by the <a
    * href="https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/0b0516bd1a0599c8f536cc6b2151782000681f39/gradle/instrumentation-common.gradle#L8">opentelemetry-java-instrumentation</a>.

buildSrc/src/main/java/io/opentelemetry/instrumentation/gradle/OpenTelemetryUnShadePlugin.java

@@ -0,0 +1,33 @@
+package io.opentelemetry.instrumentation.gradle;
+
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaLibraryPlugin;
+
+/**
+ * Plugin to encapsulate our rather odd practice of depending on a shaded instrumentation JAR
+ * published by OpenTelemetry, un-shading the OTEL public API by relocating the packages to their
+ * original location so we can use the utilities exposed in the not-shaded OTEL
+ * instrumentation library classes.
+ */
+public final class OpenTelemetryUnShadePlugin implements Plugin<Project> {
+
+  @Override
+  public void apply(final Project project) {
+    project.getPlugins().apply(JavaLibraryPlugin.class);
+    project.getPlugins().apply("com.github.johnrengelman.shadow");
+    project.getTasks().named("shadowJar", ShadowJar.class).configure(shadowJar -> {
+      shadowJar.relocate("io.opentelemetry.javaagent.shaded.io.opentelemetry.api",
+          "io.opentelemetry.api");
+      shadowJar.relocate("io.opentelemetry.javaagent.shaded.io.opentelemetry.context",
+          "io.opentelemetry.context");
+      shadowJar.relocate("io.opentelemetry.javaagent.shaded.io.opentelemetry.semconv",
+          "io.opentelemetry.semconv");
+      shadowJar.relocate("io.opentelemetry.javaagent.shaded.instrumentation.api",
+          "io.opentelemetry.instrumentation.api");
+      shadowJar.relocate("io.opentelemetry.javaagent.slf4j", "org.slf4j");
+    });
+
+  }
+}

buildSrc/src/main/java/io/opentelemetry/instrumentation/gradle/bytebuddy/ByteBuddyPluginConfigurator.java

@@ -9,11 +9,15 @@
 import java.io.File;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
 import net.bytebuddy.build.gradle.ByteBuddySimpleTask;
 import net.bytebuddy.build.gradle.Transformation;
+import org.gradle.api.Action;
 import org.gradle.api.Project;
 import org.gradle.api.Task;
 import org.gradle.api.tasks.SourceSet;
+import org.gradle.api.tasks.TaskProvider;
 import org.gradle.api.tasks.compile.AbstractCompile;
 
 /**
@@ -35,6 +39,7 @@
  * of the compile task.
  */
 public class ByteBuddyPluginConfigurator {
+
   private static final List<String> LANGUAGES = Arrays.asList("java", "scala", "kotlin");
 
   private final Project project;
@@ -61,43 +66,67 @@ public ByteBuddyPluginConfigurator(
 
   public void configure() {
     String taskName = getTaskName();
-    Task byteBuddyTask = project.getTasks().create(taskName);
-
-    for (String language : LANGUAGES) {
-      AbstractCompile compile = getCompileTask(language);
-
-      if (compile != null) {
-        Task languageTask = createLanguageTask(compile, taskName + language);
-        // We also process resources for SPI classes.
-        languageTask.dependsOn(sourceSet.getProcessResourcesTaskName());
-        byteBuddyTask.dependsOn(languageTask);
-      }
-    }
 
-    project.getTasks().getByName(sourceSet.getClassesTaskName()).dependsOn(byteBuddyTask);
+    List<TaskProvider<?>> languageTasks =
+        LANGUAGES.stream()
+            .map(
+                language -> {
+                  if (project.fileTree("src/" + sourceSet.getName() + "/" + language).isEmpty()) {
+                    return null;
+                  }
+                  String compileTaskName = sourceSet.getCompileTaskName(language);
+                  if (!project.getTasks().getNames().contains(compileTaskName)) {
+                    return null;
+                  }
+                  TaskProvider<?> compileTask = project.getTasks().named(compileTaskName);
+
+                  // We also process resources for SPI classes.
+                  return createLanguageTask(
+                      compileTask, taskName + language, sourceSet.getProcessResourcesTaskName());
+                })
+            .filter(Objects::nonNull)
+            .collect(Collectors.toList());
+
+    TaskProvider<?> byteBuddyTask =
+        project.getTasks().register(taskName, task -> task.dependsOn(languageTasks));
+
+    project
+        .getTasks()
+        .named(sourceSet.getClassesTaskName())
+        .configure(task -> task.dependsOn(byteBuddyTask));
   }
 
-  private Task createLanguageTask(AbstractCompile compileTask, String name) {
-    ByteBuddySimpleTask task = project.getTasks().create(name, ByteBuddySimpleTask.class);
-    task.setGroup("Byte Buddy");
-    task.getOutputs().cacheIf(unused -> true);
-
-    File classesDirectory = compileTask.getDestinationDir();
-    File rawClassesDirectory =
-        new File(classesDirectory.getParent(), classesDirectory.getName() + "raw")
-            .getAbsoluteFile();
-
-    task.dependsOn(compileTask);
-    compileTask.setDestinationDir(rawClassesDirectory);
-
-    task.setSource(rawClassesDirectory);
-    task.setTarget(classesDirectory);
-    task.setClassPath(compileTask.getClasspath());
-
-    task.dependsOn(compileTask);
-
-    task.getTransformations().add(createTransformation(inputClasspath, pluginClassName));
-    return task;
+  private TaskProvider<?> createLanguageTask(
+      TaskProvider<?> compileTaskProvider, String name, String processResourcesTaskName) {
+    return project
+        .getTasks()
+        .register(
+            name,
+            ByteBuddySimpleTask.class,
+            task -> {
+              task.setGroup("Byte Buddy");
+              task.getOutputs().cacheIf(unused -> true);
+
+              Task maybeCompileTask = compileTaskProvider.get();
+              if (maybeCompileTask instanceof AbstractCompile) {
+                AbstractCompile compileTask = (AbstractCompile) maybeCompileTask;
+                File classesDirectory = compileTask.getDestinationDirectory().getAsFile().get();
+                File rawClassesDirectory =
+                    new File(classesDirectory.getParent(), classesDirectory.getName() + "raw")
+                        .getAbsoluteFile();
+
+                task.dependsOn(compileTask);
+                compileTask.getDestinationDirectory().set(rawClassesDirectory);
+
+                task.setSource(rawClassesDirectory);
+                task.setTarget(classesDirectory);
+                task.setClassPath(compileTask.getClasspath());
+
+                task.dependsOn(compileTask, processResourcesTaskName);
+              }
+
+              task.getTransformations().add(createTransformation(inputClasspath, pluginClassName));
+            });
   }
 
   private AbstractCompile getCompileTask(String language) {

instrumentation/apache-httpasyncclient-4.1/build.gradle.kts

@@ -30,8 +30,7 @@ dependencies {
     api(project(":instrumentation:java-streams"))
     api(project(":instrumentation:apache-httpclient-4.0"))
 
-    api("io.opentelemetry.javaagent.instrumentation:opentelemetry-javaagent-apache-httpasyncclient-4.1:${versions["opentelemetry_java_agent"]}")
-
+    implementation(project(":instrumentation:otel-apache-httpasyncclient-unshaded", "shadow"))
     library("org.apache.httpcomponents:httpasyncclient:4.1")
      testImplementation(testFixtures(project(":testing-common")))
 }