indy instrumentation - leftovers migration

instrumentation/internal/internal-lambda/javaagent/build.gradle.kts

@@ -4,7 +4,6 @@ plugins {
 
 dependencies {
   compileOnly(project(":javaagent-bootstrap"))
-  implementation(project(":instrumentation:internal:internal-lambda-java9:javaagent"))
 
   testImplementation(project(":javaagent-bootstrap"))
 }

instrumentation/internal/internal-lambda/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/internal/lambda/LambdaInstrumentationModule.java

@@ -10,13 +10,14 @@
 import com.google.auto.service.AutoService;
 import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule;
 import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.extension.instrumentation.internal.ExperimentalInstrumentationModule;
 import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
-import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
-import net.bytebuddy.utility.JavaModule;
 
 @AutoService(InstrumentationModule.class)
-public class LambdaInstrumentationModule extends InstrumentationModule {
+public class LambdaInstrumentationModule extends InstrumentationModule
+    implements ExperimentalInstrumentationModule {
   public LambdaInstrumentationModule() {
     super("internal-lambda");
   }
@@ -28,21 +29,16 @@ public boolean defaultEnabled(ConfigProperties config) {
   }
 
   @Override
-  public boolean isIndyModule() {
-    return false;
+  public List<String> injectedClassNames() {
+    return Collections.singletonList(
+        "io.opentelemetry.javaagent.instrumentation.internal.lambda.LambdaTransformer");
   }
 
   @Override
   public List<String> getAdditionalHelperClassNames() {
     // this instrumentation uses ASM not ByteBuddy so muzzle doesn't automatically add helper
     // classes
-    List<String> classNames = new ArrayList<>();
-    classNames.add("io.opentelemetry.javaagent.instrumentation.internal.lambda.LambdaTransformer");
-    if (JavaModule.isSupported()) {
-      classNames.add(
-          "io.opentelemetry.javaagent.instrumentation.internal.lambda.Java9LambdaTransformer");
-    }
-    return classNames;
+    return injectedClassNames();
   }
 
   @Override

instrumentation/internal/internal-lambda/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/internal/lambda/LambdaTransformer.java

@@ -11,19 +11,9 @@
 
 /** Helper class for transforming lambda class bytes. */
 public final class LambdaTransformer {
-  private static final boolean IS_JAVA_9 = isJava9();
 
   private LambdaTransformer() {}
 
-  private static boolean isJava9() {
-    try {
-      Class.forName("java.lang.Module", false, null);
-      return true;
-    } catch (ClassNotFoundException exception) {
-      return false;
-    }
-  }
-
   /**
    * Called from {@code java.lang.invoke.InnerClassLambdaMetafactory} to transform lambda class
    * bytes.
@@ -34,29 +24,25 @@ public static byte[] transform(byte[] classBytes, String slashClassName, Class<?
     if (InjectedClassHelper.isHelperClass(targetClass)) {
       return classBytes;
     }
+    ClassFileTransformer transformer = ClassFileTransformerHolder.getLambdaClassFileTransformer();
+    if (transformer == null) {
+      return classBytes;
+    }
 
-    ClassFileTransformer transformer = ClassFileTransformerHolder.getClassFileTransformer();
-    if (transformer != null) {
-      try {
-        byte[] result;
-        if (IS_JAVA_9) {
-          result =
-              Java9LambdaTransformer.transform(
-                  transformer, classBytes, slashClassName, targetClass);
-        } else {
-          result =
-              transformer.transform(
-                  targetClass.getClassLoader(), slashClassName, null, null, classBytes);
-        }
-        if (result != null) {
-          return result;
-        }
-      } catch (Throwable throwable) {
-        // sun.instrument.TransformerManager catches Throwable from ClassFileTransformer and ignores
-        // it, we do the same.
+    try {
+      // The 'targetClass' needs to be non-null as it is used in Java9LambdaClassFileTransformer
+      // to get a reference to the jpms module. However, a null value must be passed to the
+      // underlying transformer as this code is called when the lambda is defined.
+      byte[] result =
+          transformer.transform(
+              targetClass.getClassLoader(), slashClassName, targetClass, null, classBytes);
+      if (result != null) {
+        classBytes = result;
       }
+    } catch (Throwable throwable) {
+      // sun.instrument.TransformerManager catches Throwable from ClassFileTransformer and ignores
+      // it, we do the same.
     }
-
     return classBytes;
   }
 }

instrumentation/kotlinx-coroutines/kotlinx-coroutines-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/kotlinxcoroutines/instrumentationannotations/AnnotationInstrumentationHelper.java

@@ -15,12 +15,20 @@
 import kotlin.coroutines.Continuation;
 import kotlin.coroutines.intrinsics.IntrinsicsKt;
 
+/**
+ * Instrumentation helper that is called through bytecode instrumentation. When using invokedynamic
+ * instrumentation this class is called through an injected proxy, and thus it should not pull any
+ * other class references than the ones that are already present in the target classloader or the
+ * bootstrap classloader. This is why the {@link MethodRequest} class is here passed as an {@link
+ * Object} as it allows to avoid having to inject extra classes in the target classloader
+ */
+@SuppressWarnings("unused") // methods calls injected through bytecode instrumentation
 public final class AnnotationInstrumentationHelper {
 
   private static final VirtualField<Continuation<?>, Context> contextField =
       VirtualField.find(Continuation.class, Context.class);
 
-  public static MethodRequest createMethodRequest(
+  public static Object createMethodRequest(
       Class<?> declaringClass, String methodName, String withSpanValue, String spanKindString) {
     SpanKind spanKind = SpanKind.INTERNAL;
     if (spanKindString != null) {
@@ -34,11 +42,10 @@ public static MethodRequest createMethodRequest(
     return MethodRequest.create(declaringClass, methodName, withSpanValue, spanKind);
   }
 
-  public static Context enterCoroutine(
-      int label, Continuation<?> continuation, MethodRequest request) {
+  public static Context enterCoroutine(int label, Continuation<?> continuation, Object request) {
     // label 0 means that coroutine is started, any other label means that coroutine is resumed
     if (label == 0) {
-      Context context = instrumenter().start(Context.current(), request);
+      Context context = instrumenter().start(Context.current(), (MethodRequest) request);
       // null continuation means that this method is not going to be resumed, and we don't need to
       // store the context
       if (continuation != null) {
@@ -55,18 +62,14 @@ public static Scope openScope(Context context) {
   }
 
   public static void exitCoroutine(
-      Object result,
-      MethodRequest request,
-      Continuation<?> continuation,
-      Context context,
-      Scope scope) {
+      Object result, Object request, Continuation<?> continuation, Context context, Scope scope) {
     exitCoroutine(null, result, request, continuation, context, scope);
   }
 
   public static void exitCoroutine(
       Throwable error,
       Object result,
-      MethodRequest request,
+      Object request,
       Continuation<?> continuation,
       Context context,
       Scope scope) {
@@ -78,7 +81,7 @@ public static void exitCoroutine(
     // end the span when this method can not be resumed (coroutine is null) or if it has reached
     // final state (returns anything else besides COROUTINE_SUSPENDED)
     if (continuation == null || result != IntrinsicsKt.getCOROUTINE_SUSPENDED()) {
-      instrumenter().end(context, request, null, error);
+      instrumenter().end(context, (MethodRequest) request, null, error);
     }
   }
 

instrumentation/kotlinx-coroutines/kotlinx-coroutines-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/kotlinxcoroutines/instrumentationannotations/AnnotationInstrumentationModule.java

@@ -11,12 +11,16 @@
 import com.google.auto.service.AutoService;
 import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule;
 import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.extension.instrumentation.internal.ExperimentalInstrumentationModule;
+import io.opentelemetry.javaagent.extension.instrumentation.internal.injection.ClassInjector;
+import io.opentelemetry.javaagent.extension.instrumentation.internal.injection.InjectionMode;
 import java.util.List;
 import net.bytebuddy.matcher.ElementMatcher;
 
 /** Instrumentation for methods annotated with {@code WithSpan} annotation. */
 @AutoService(InstrumentationModule.class)
-public class AnnotationInstrumentationModule extends InstrumentationModule {
+public class AnnotationInstrumentationModule extends InstrumentationModule
+    implements ExperimentalInstrumentationModule {
 
   public AnnotationInstrumentationModule() {
     super(
@@ -26,12 +30,6 @@ public AnnotationInstrumentationModule() {
         "opentelemetry-instrumentation-annotations");
   }
 
-  @Override
-  public boolean isIndyModule() {
-    // needs helper classes in the same class loader
-    return false;
-  }
-
   @Override
   public int order() {
     // Run first to ensure other automatic instrumentation is added after and therefore is executed
@@ -50,4 +48,17 @@ public ElementMatcher.Junction<ClassLoader> classLoaderMatcher() {
   public List<TypeInstrumentation> typeInstrumentations() {
     return singletonList(new WithSpanInstrumentation());
   }
+
+  @Override
+  public void injectClasses(ClassInjector injector) {
+    // AnnotationInstrumentationHelper is called directly in the instrumented bytecode.
+    //
+    // With invokedynamic instrumentation a proxy class can be used as long as it does not pull
+    // extra types in the method signatures (which would require those types to also be available
+    // in the instrumented code).
+    injector
+        .proxyBuilder(
+            "io.opentelemetry.javaagent.instrumentation.kotlinxcoroutines.instrumentationannotations.AnnotationInstrumentationHelper")
+        .inject(InjectionMode.CLASS_ONLY);
+  }
 }