Fix redefinition failure on openj9

instrumentation/internal/internal-reflection/bootstrap/build.gradle.kts

@@ -0,0 +1,3 @@
+plugins {
+  id("otel.javaagent-bootstrap")
+}

instrumentation/internal/internal-reflection/bootstrap/src/main/java/io/opentelemetry/javaagent/instrumentation/internal/reflection/VirtualFieldDetector.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.internal.reflection;
+
+import io.opentelemetry.instrumentation.api.cache.Cache;
+
+/** Helper class for detecting whether given class has virtual fields. */
+public final class VirtualFieldDetector {
+
+  private static final Cache<Class<?>, Boolean> classesWithVirtualFields = Cache.weak();
+
+  private VirtualFieldDetector() {}
+
+  /**
+   * Detect whether given class has virtual fields. This method looks for virtual fields only from
+   * the specified class not its super classes.
+   *
+   * @param clazz a class
+   * @return true if given class has virtual fields
+   */
+  public static boolean hasVirtualFields(Class<?> clazz) {
+    // clazz.getInterfaces() needs to be called before reading from classesWithVirtualFields
+    // as the call to clazz.getInterfaces() triggers adding clazz to that map via instrumentation
+    // calling VirtualFieldDetector#markVirtualFieldsPresent() from Class#getInterfaces()
+    clazz.getInterfaces();
+    return classesWithVirtualFields.get(clazz) != null;
+  }
+
+  static void markVirtualFieldsPresent(Class<?> clazz) {
+    classesWithVirtualFields.put(clazz, Boolean.TRUE);
+  }
+}

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

@@ -3,6 +3,8 @@ plugins {
 }
 
 dependencies {
+  bootstrap(project(":instrumentation:internal:internal-reflection:bootstrap"))
+
   compileOnly(project(":javaagent-bootstrap"))
 
   testImplementation(project(":javaagent-bootstrap"))

instrumentation/internal/internal-reflection/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/internal/reflection/ReflectionHelper.java

@@ -60,16 +60,23 @@ public static Class<?>[] filterInterfaces(Class<?>[] interfaces, Class<?> contai
       return interfaces;
     }
     List<Class<?>> result = new ArrayList<>(interfaces.length);
+    boolean hasVirtualFieldMarker = false;
     for (Class<?> interfaceClass : interfaces) {
       // filter out virtual field marker and accessor interfaces
       if (interfaceClass == VirtualFieldInstalledMarker.class
           || (VirtualFieldAccessorMarker.class.isAssignableFrom(interfaceClass)
               && interfaceClass.isSynthetic()
               && interfaceClass.getName().contains("VirtualFieldAccessor$"))) {
+        hasVirtualFieldMarker = true;
         continue;
       }
       result.add(interfaceClass);
     }
+
+    if (hasVirtualFieldMarker) {
+      VirtualFieldDetector.markVirtualFieldsPresent(containingClass);
+    }
+
     return result.toArray(new Class<?>[0]);
   }
 }

javaagent-tooling/build.gradle.kts

@@ -18,6 +18,7 @@ dependencies {
   implementation(project(":instrumentation-api-appender"))
   implementation(project(":instrumentation-sdk-appender"))
   implementation(project(":muzzle"))
+  implementation(project(":instrumentation:internal:internal-reflection:bootstrap"))
 
   implementation("io.opentelemetry:opentelemetry-api")
   implementation("io.opentelemetry:opentelemetry-api-metrics")

javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/FieldBackedImplementationInstaller.java

@@ -12,13 +12,12 @@
 
 import io.opentelemetry.instrumentation.api.config.Config;
 import io.opentelemetry.javaagent.bootstrap.InstrumentationHolder;
-import io.opentelemetry.javaagent.bootstrap.VirtualFieldInstalledMarker;
+import io.opentelemetry.javaagent.instrumentation.internal.reflection.VirtualFieldDetector;
 import io.opentelemetry.javaagent.tooling.HelperInjector;
 import io.opentelemetry.javaagent.tooling.TransformSafeLogger;
 import io.opentelemetry.javaagent.tooling.instrumentation.InstrumentationModuleInstaller;
 import io.opentelemetry.javaagent.tooling.muzzle.VirtualFieldMappings;
 import java.lang.instrument.Instrumentation;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Map;
@@ -216,14 +215,10 @@ private static AgentBuilder.RawMatcher safeToInjectFieldsMatcher() {
       /*
        * The idea here is that we can add fields if class is just being loaded
        * (classBeingRedefined == null) and we have to add same fields again if class we added
-       * fields before is being transformed again. Note: here we assume that Class#getInterfaces()
-       * returns list of interfaces defined immediately on a given class, not inherited from its
-       * parents. It looks like current JVM implementation does exactly this but javadoc is not
-       * explicit about that.
+       * fields before is being transformed again.
        */
       return classBeingRedefined == null
-          || Arrays.asList(classBeingRedefined.getInterfaces())
-              .contains(VirtualFieldInstalledMarker.class);
+          || VirtualFieldDetector.hasVirtualFields(classBeingRedefined);
     };
   }
 

settings.gradle.kts

@@ -153,6 +153,7 @@ include(":instrumentation:internal:internal-class-loader:javaagent-integration-t
 include(":instrumentation:internal:internal-eclipse-osgi-3.6:javaagent")
 include(":instrumentation:internal:internal-lambda:javaagent")
 include(":instrumentation:internal:internal-lambda-java9:javaagent")
+include(":instrumentation:internal:internal-reflection:bootstrap")
 include(":instrumentation:internal:internal-reflection:javaagent")
 include(":instrumentation:internal:internal-reflection:javaagent-integration-tests")
 include(":instrumentation:internal:internal-url-class-loader:javaagent")