indy instrumentation - leftovers migration

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

@@ -128,7 +128,7 @@ public void visitMethodInsn(
                       Opcodes.GETFIELD, slashClassName, "targetClass", "Ljava/lang/Class;");
                   mv.visitMethodInsn(
                       Opcodes.INVOKESTATIC,
-                      Type.getInternalName(LambdaTransformer.class),
+                      Type.getInternalName(LambdaTransformerHelper.class),
                       "transform",
                       "([BLjava/lang/String;Ljava/lang/Class;)[B",
                       false);

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

@@ -5,14 +5,14 @@
 
 package io.opentelemetry.javaagent.instrumentation.internal.lambda;
 
-import io.opentelemetry.javaagent.bootstrap.ClassFileTransformerHolder;
 import io.opentelemetry.javaagent.bootstrap.InjectedClassHelper;
-import java.lang.instrument.ClassFileTransformer;
+import io.opentelemetry.javaagent.bootstrap.LambdaTransformer;
+import io.opentelemetry.javaagent.bootstrap.LambdaTransformerHolder;
 
 /** Helper class for transforming lambda class bytes. */
-public final class LambdaTransformer {
+public final class LambdaTransformerHelper {
 
-  private LambdaTransformer() {}
+  private LambdaTransformerHelper() {}
 
   /**
    * Called from {@code java.lang.invoke.InnerClassLambdaMetafactory} to transform lambda class
@@ -24,18 +24,13 @@ public static byte[] transform(byte[] classBytes, String slashClassName, Class<?
     if (InjectedClassHelper.isHelperClass(targetClass)) {
       return classBytes;
     }
-    ClassFileTransformer transformer = ClassFileTransformerHolder.getLambdaClassFileTransformer();
+    LambdaTransformer transformer = LambdaTransformerHolder.setLambdaTransformer();
     if (transformer == null) {
       return classBytes;
     }
 
     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);
+      byte[] result = transformer.transform(slashClassName, targetClass, classBytes);
       if (result != null) {
         classBytes = result;
       }

javaagent-bootstrap/src/main/java/io/opentelemetry/javaagent/bootstrap/LambdaTransformer.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.bootstrap;
+
+import java.lang.instrument.IllegalClassFormatException;
+
+/** Transformer for lambda bytecode */
+public interface LambdaTransformer {
+
+  /**
+   * Transforms lambda bytecode for instrumentation
+   *
+   * @param className class name in JVM format with slashes
+   * @param targetClass target class, must not be {@literal null}
+   * @param classfileBuffer target class bytecode
+   * @return instrumented lambda bytecode
+   * @throws IllegalClassFormatException if bytecode is invalid
+   */
+  byte[] transform(String className, Class<?> targetClass, byte[] classfileBuffer)
+      throws IllegalClassFormatException;
+}

javaagent-bootstrap/src/main/java/io/opentelemetry/javaagent/bootstrap/LambdaTransformerHolder.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.bootstrap;
+
+/**
+ * Holder for {@link LambdaTransformer} used by the instrumentation. Calling transform on this
+ * transformer processes given bytes the same way as they would be processed during loading of the
+ * class.
+ */
+public final class LambdaTransformerHolder {
+
+  private static volatile LambdaTransformer lambdaTransformer;
+
+  /**
+   * get lambda transformer
+   *
+   * @return class transformer for defining lambdas
+   */
+  public static LambdaTransformer setLambdaTransformer() {
+    return lambdaTransformer;
+  }
+
+  /**
+   * set lambda transformer
+   *
+   * @param transformer transformer
+   */
+  public static void setLambdaTransformer(LambdaTransformer transformer) {
+    lambdaTransformer = transformer;
+  }
+
+  private LambdaTransformerHolder() {}
+}

javaagent-tooling/javaagent-tooling-java9/src/main/java/io/opentelemetry/javaagent/tooling/Java9LambdaTransformer.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.tooling;
+
+import io.opentelemetry.javaagent.bootstrap.LambdaTransformer;
+import java.lang.instrument.ClassFileTransformer;
+import java.lang.instrument.IllegalClassFormatException;
+
+/** lambda transformer with java9 jpms module compatibility */
+public class Java9LambdaTransformer implements LambdaTransformer {
+
+  private final ClassFileTransformer delegate;
+
+  public Java9LambdaTransformer(ClassFileTransformer delegate) {
+    this.delegate = delegate;
+  }
+
+  @Override
+  public byte[] transform(String className, Class<?> targetClass, byte[] classfileBuffer)
+      throws IllegalClassFormatException {
+
+    // lambda instrumentation happens only when the lambda is defined, thus the classBeingRedefined
+    // must be null otherwise we get a partial instrumentation, for example virtual fields are not
+    // properly applied
+    return delegate.transform(
+        targetClass.getModule(),
+        targetClass.getClassLoader(),
+        className,
+        null,
+        null,
+        classfileBuffer);
+  }
+}

javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/AgentInstaller.java

@@ -21,9 +21,10 @@
 import io.opentelemetry.instrumentation.api.internal.EmbeddedInstrumentationProperties;
 import io.opentelemetry.javaagent.bootstrap.AgentClassLoader;
 import io.opentelemetry.javaagent.bootstrap.BootstrapPackagePrefixesHolder;
-import io.opentelemetry.javaagent.bootstrap.ClassFileTransformerHolder;
 import io.opentelemetry.javaagent.bootstrap.DefineClassHelper;
 import io.opentelemetry.javaagent.bootstrap.InstrumentedTaskClasses;
+import io.opentelemetry.javaagent.bootstrap.LambdaTransformer;
+import io.opentelemetry.javaagent.bootstrap.LambdaTransformerHolder;
 import io.opentelemetry.javaagent.bootstrap.http.HttpServerResponseCustomizer;
 import io.opentelemetry.javaagent.bootstrap.http.HttpServerResponseCustomizerHolder;
 import io.opentelemetry.javaagent.bootstrap.http.HttpServerResponseMutator;
@@ -200,14 +201,15 @@ private static void installBytebuddyAgent(
 
     agentBuilder = AgentBuilderUtil.optimize(agentBuilder);
     ClassFileTransformer transformer = agentBuilder.installOn(inst);
+    LambdaTransformer lambdaTransformer;
     if (JavaModule.isSupported()) {
       // wrapping in a JPMS compliant implementation
-      transformer = new Java9LambdaClassFileTransformer(transformer);
+      lambdaTransformer = new Java9LambdaTransformer(transformer);
     } else {
       // wrapping in a java 8 compliant transformer
-      transformer = new LambdaClassFileTransformer(transformer);
+      lambdaTransformer = new Java8LambdaTransformer(transformer);
     }
-    ClassFileTransformerHolder.setLambdaClassFileTransformer(transformer);
+    LambdaTransformerHolder.setLambdaTransformer(lambdaTransformer);
 
     instrumentationInstalled = true;
 

javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/LambdaClassFileTransformer.java → javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/Java8LambdaTransformer.java

@@ -5,31 +5,26 @@
 
 package io.opentelemetry.javaagent.tooling;
 
+import io.opentelemetry.javaagent.bootstrap.LambdaTransformer;
 import java.lang.instrument.ClassFileTransformer;
 import java.lang.instrument.IllegalClassFormatException;
-import java.security.ProtectionDomain;
 
-/** {@link ClassFileTransformer} for lambda instrumentation without jpms modules */
-public class LambdaClassFileTransformer implements ClassFileTransformer {
+/** lambda transformer for java < 9 without jpms modules support */
+public class Java8LambdaTransformer implements LambdaTransformer {
 
   private final ClassFileTransformer delegate;
 
-  public LambdaClassFileTransformer(ClassFileTransformer delegate) {
+  public Java8LambdaTransformer(ClassFileTransformer delegate) {
     this.delegate = delegate;
   }
 
   @Override
-  public byte[] transform(
-      ClassLoader loader,
-      String className,
-      Class<?> classBeingRedefined,
-      ProtectionDomain protectionDomain,
-      byte[] classfileBuffer)
+  public byte[] transform(String className, Class<?> targetClass, byte[] classfileBuffer)
       throws IllegalClassFormatException {
 
     // lambda instrumentation happens only when the lambda is defined, thus the classBeingRedefined
     // must be null otherwise we get a partial instrumentation, for example virtual fields are not
     // properly applied.
-    return delegate.transform(loader, className, null, null, classfileBuffer);
+    return delegate.transform(targetClass.getClassLoader(), className, null, null, classfileBuffer);
   }
 }