Merge remote-tracking branch 'origin/master' into PROF-13025

Author: rkennke

.github/CODEOWNERS

@@ -116,7 +116,8 @@
 **/DataStreams*                                                              @DataDog/data-streams-monitoring
 
 # @DataDog/feature-flagging-and-experimentation-sdk
-/products/feature-flagging/                           @DataDog/feature-flagging-and-experimentation-sdk
+/dd-smoke-tests/openfeature/                                    @DataDog/feature-flagging-and-experimentation-sdk
+/products/feature-flagging/                                     @DataDog/feature-flagging-and-experimentation-sdk
 
 # @DataDog/profiling-java
 /dd-java-agent/agent-profiling/                                                             @DataDog/profiling-java

components/environment/src/main/java/datadog/environment/JavaVirtualMachine.java

@@ -108,8 +108,12 @@ public static boolean isJ9() {
     return SystemProperties.getOrDefault("java.vm.name", "").contains("J9");
   }
 
+  public static boolean isIbm() {
+    return runtime.vendor.contains("IBM");
+  }
+
   public static boolean isIbm8() {
-    return isJavaVersion(8) && runtime.vendor.contains("IBM");
+    return isIbm() && isJavaVersion(8);
   }
 
   public static boolean isGraalVM() {

components/environment/src/test/java/datadog/environment/JavaVirtualMachineTest.java

@@ -113,6 +113,7 @@ void onlyOnGraalVm() {
   @EnabledOnJre(JAVA_8)
   void onlyOnIbm8() {
     assertFalse(JavaVirtualMachine.isGraalVM());
+    assertTrue(JavaVirtualMachine.isIbm());
     assertTrue(JavaVirtualMachine.isIbm8());
     assertTrue(JavaVirtualMachine.isJ9());
     assertFalse(JavaVirtualMachine.isOracleJDK8());

dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/muzzle/MuzzleVersionScanPlugin.java

@@ -8,6 +8,7 @@
 import de.thetaphi.forbiddenapis.SuppressForbidden;
 import java.io.IOException;
 import java.io.PrintWriter;
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
@@ -16,6 +17,7 @@
 import java.util.Map;
 import java.util.ServiceLoader;
 import java.util.Set;
+import java.util.function.BiConsumer;
 import net.bytebuddy.dynamic.ClassFileLocator;
 
 /**
@@ -75,9 +77,9 @@ public static void assertInstrumentationMuzzled(
           // verify helper consistency
           final String[] helperClassNames = module.helperClassNames();
           if (helperClassNames.length > 0) {
-            HelperClassLoader helperClassLoader = new HelperClassLoader(testApplicationLoader);
+            BiConsumer<String, byte[]> injectClassHelper = injectClassHelper(testApplicationLoader);
             for (Map.Entry<String, byte[]> helper : createHelperMap(module).entrySet()) {
-              helperClassLoader.injectClass(helper.getKey(), helper.getValue());
+              injectClassHelper.accept(helper.getKey(), helper.getValue());
             }
           }
         } catch (final Throwable e) {
@@ -90,6 +92,29 @@ public static void assertInstrumentationMuzzled(
     }
   }
 
+  /** Simulates instrumentation-based access to defineClass feature. */
+  private static BiConsumer<String, byte[]> injectClassHelper(ClassLoader cl) {
+    try {
+      Method findLoadedClass = ClassLoader.class.getDeclaredMethod("findLoadedClass", String.class);
+      Method defineClass =
+          ClassLoader.class.getDeclaredMethod(
+              "defineClass", String.class, byte[].class, int.class, int.class);
+      findLoadedClass.setAccessible(true);
+      defineClass.setAccessible(true);
+      return (name, bytes) -> {
+        try {
+          if (findLoadedClass.invoke(cl, name) == null) {
+            defineClass.invoke(cl, name, bytes, 0, bytes.length);
+          }
+        } catch (ReflectiveOperationException e) {
+          throw new RuntimeException(e);
+        }
+      };
+    } catch (ReflectiveOperationException e) {
+      return new HelperClassLoader(cl)::injectClass;
+    }
+  }
+
   // build modules to test while single-threaded to match installer assumptions
   private static synchronized List<InstrumenterModule> toBeTested(
       ClassLoader instrumentationLoader, String muzzleDirective) {
@@ -114,7 +139,9 @@ static final class HelperClassLoader extends ClassLoader {
     }
 
     public void injectClass(String name, byte[] bytecode) {
-      defineClass(name, bytecode, 0, bytecode.length);
+      if (findLoadedClass(name) == null) {
+        defineClass(name, bytecode, 0, bytecode.length);
+      }
     }
   }
 

dd-java-agent/instrumentation/jboss/jboss-modules-1.3/build.gradle

@@ -8,6 +8,16 @@ muzzle {
 
 apply from: "$rootDir/gradle/java.gradle"
 
+addTestSuite("latestDepTest")
+
 dependencies {
   compileOnly group: 'org.jboss.modules', name: 'jboss-modules', version: '1.3.0.Final'
+  testImplementation group: 'org.jboss.modules', name: 'jboss-modules', version: '1.3.0.Final'
+  latestDepTestImplementation group: 'org.jboss.modules', name: 'jboss-modules', version: '+'
+}
+
+tasks.withType(Test).configureEach {
+  if (it.javaVersion.isJava9Compatible()) {
+    jvmArgs +='--add-exports=java.xml/com.sun.org.apache.xerces.internal.jaxp=ALL-UNNAMED'
+  }
 }

dd-java-agent/instrumentation/jboss/jboss-modules-1.3/src/latestDepTest/groovy/ModuleNameExtractionTest.groovy

@@ -0,0 +1,21 @@
+import datadog.trace.agent.test.InstrumentationSpecification
+import datadog.trace.instrumentation.jbossmodules.ModuleNameHelper
+import org.jboss.modules.DependencySpec
+import org.jboss.modules.Module
+import org.jboss.modules.ModuleSpec
+
+class ModuleNameExtractionTest extends InstrumentationSpecification {
+  def "should be able to extract a module name"() {
+    given:
+
+    ModuleSpec spec = ModuleSpec.build("dummy")
+      .addDependency(DependencySpec.createLocalDependencySpec())
+      .create()
+
+    Module module = new Module(spec, Module.getBootModuleLoader())
+
+    expect:
+    module != null
+    module.getName() == ModuleNameHelper.extractModuleName(module)
+  }
+}

dd-java-agent/instrumentation/jboss/jboss-modules-1.3/src/main/java/datadog/trace/instrumentation/jbossmodules/ModuleNameHelper.java

@@ -1,19 +1,77 @@
 package datadog.trace.instrumentation.jbossmodules;
 
+import datadog.trace.util.MethodHandles;
+import java.lang.invoke.MethodHandle;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import javax.annotation.Nonnull;
+import org.jboss.modules.Module;
 import org.jboss.modules.ModuleClassLoader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class ModuleNameHelper {
   private ModuleNameHelper() {}
 
+  private static final Logger LOGGER = LoggerFactory.getLogger(ModuleNameHelper.class);
+  private static final MethodHandle MODULE_NAME_GETTER = resolveModuleNameGetter();
+
+  private static MethodHandle resolveModuleNameGetter() {
+    final ClassLoader classLoader = ModuleClassLoader.class.getClassLoader();
+    final MethodHandles methodHandles = new MethodHandles(classLoader);
+    MethodHandle ret = null;
+    MethodHandle getModuleIdentifierHandle = null;
+    try {
+      // before 2.2
+      getModuleIdentifierHandle = methodHandles.method(Module.class, "getIdentifier");
+      if (getModuleIdentifierHandle != null) {
+        // chains the two method handle calls
+        ret =
+            java.lang.invoke.MethodHandles.filterReturnValue(
+                getModuleIdentifierHandle,
+                methodHandles.method(
+                    Class.forName("org.jboss.modules.ModuleIdentifier", false, classLoader),
+                    "getName"));
+      }
+    } catch (Throwable ignored) {
+      // here for caution. It's already caught and logged on MethodHandles
+    }
+    if (ret == null) {
+      // 2.2 onward
+      try {
+        ret = methodHandles.method(Module.class, "getName");
+      } catch (Throwable ignored) {
+      }
+    }
+    if (ret == null) {
+      LOGGER.debug(
+          "Unable to resolve a method to establish jboss module name. If enabled, jee-split-by-deployment will not work properly");
+    }
+    return ret;
+  }
+
   private static final Pattern SUBDEPLOYMENT_MATCH =
       Pattern.compile("deployment(?>.+\\.ear)?\\.(.+)\\.[j|w]ar");
 
+  static String extractModuleName(Module module) {
+    if (MODULE_NAME_GETTER == null) {
+      return null;
+    }
+    String moduleName = null;
+    try {
+      moduleName = (String) MODULE_NAME_GETTER.invoke(module);
+    } catch (Throwable ignored) {
+    }
+    return moduleName;
+  }
+
   public static String extractDeploymentName(@Nonnull final ModuleClassLoader classLoader) {
-    final Matcher matcher =
-        SUBDEPLOYMENT_MATCH.matcher(classLoader.getModule().getIdentifier().getName());
+
+    final String moduleName = extractModuleName(classLoader.getModule());
+    if (moduleName == null) {
+      return null;
+    }
+    final Matcher matcher = SUBDEPLOYMENT_MATCH.matcher(moduleName);
     if (matcher.matches()) {
       return matcher.group(1);
     }

dd-java-agent/instrumentation/jboss/jboss-modules-1.3/src/test/groovy/ModuleNameExtractionTest.groovy

@@ -0,0 +1,23 @@
+import datadog.trace.agent.test.InstrumentationSpecification
+import datadog.trace.instrumentation.jbossmodules.ModuleNameHelper
+import org.jboss.modules.DependencySpec
+import org.jboss.modules.Module
+import org.jboss.modules.ModuleIdentifier
+import org.jboss.modules.ModuleSpec
+
+class ModuleNameExtractionTest extends InstrumentationSpecification {
+  def "should be able to extract a module name"() {
+    given:
+    ModuleIdentifier id = ModuleIdentifier.fromString("dummy")
+
+    ModuleSpec spec = ModuleSpec.build(id)
+      .addDependency(DependencySpec.createLocalDependencySpec())
+      .create()
+
+    Module module = new Module(spec, Module.getBootModuleLoader())
+
+    expect:
+    module != null
+    module.getIdentifier().getName() == ModuleNameHelper.extractModuleName(module)
+  }
+}