Add BundleWiring instrumentation to improve tracer behaviour on OSGi:

* Rework our class-file location strategy to make it easier to mark agent requests
* Record the type of agent class-loader requests to help with OSGi instrumentation
* Widen class/resource lookup on OSGi for agent requests (and support lightweight probing)
* Enable checks for common OSGi issues in the OSGi smoke test

dd-java-agent/agent-bootstrap/src/main/java/datadog/trace/bootstrap/AgentClassLoading.java

@@ -0,0 +1,34 @@
+package datadog.trace.bootstrap;
+
+/**
+ * Helps distinguish agent class-loading requests from application requests.
+ *
+ * <p>Should be used in a short try..finally block around the class-loader call.
+ */
+public enum AgentClassLoading {
+  /** Lightweight class-loader probing to select instrumentations. */
+  PROBING_CLASSLOADER,
+  /** Locating class resources for Byte-Buddy. */
+  LOCATING_CLASS,
+  /** Injecting helper classes into class-loaders. */
+  INJECTING_HELPERS;
+
+  private static final ThreadLocal<AgentClassLoading> REQUEST = new ThreadLocal<>();
+
+  /**
+   * Gets the current agent class-loading request type; {@code null} if there's no agent request.
+   */
+  public static AgentClassLoading type() {
+    return REQUEST.get();
+  }
+
+  /** Records that this agent class-loading request has begun. */
+  public final void begin() {
+    REQUEST.set(this);
+  }
+
+  /** Records that this agent class-loading request has ended. */
+  public final void end() {
+    REQUEST.remove();
+  }
+}

dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/ClassLoaderMatcher.java

@@ -1,5 +1,7 @@
 package datadog.trace.agent.tooling;
 
+import static datadog.trace.bootstrap.AgentClassLoading.PROBING_CLASSLOADER;
+
 import datadog.trace.api.Tracer;
 import datadog.trace.bootstrap.PatchLogger;
 import datadog.trace.bootstrap.WeakCache;
@@ -140,12 +142,17 @@ private WeakCache<ClassLoader, Boolean> getCache() {
     }
 
     private boolean hasResources(final ClassLoader cl) {
-      for (final String resource : resources) {
-        if (cl.getResource(resource) == null) {
-          return false;
+      PROBING_CLASSLOADER.begin();
+      try {
+        for (final String resource : resources) {
+          if (cl.getResource(resource) == null) {
+            return false;
+          }
         }
+        return true;
+      } finally {
+        PROBING_CLASSLOADER.end();
       }
-      return true;
     }
 
     @Override

dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/HelperInjector.java

@@ -1,6 +1,7 @@
 package datadog.trace.agent.tooling;
 
 import static datadog.trace.agent.tooling.ClassLoaderMatcher.BOOTSTRAP_CLASSLOADER;
+import static datadog.trace.bootstrap.AgentClassLoading.INJECTING_HELPERS;
 
 import datadog.trace.api.Config;
 import java.io.File;
@@ -165,21 +166,28 @@ private Map<String, Class<?>> injectBootstrapClassLoader(
 
     // Failures to create a tempDir are propagated as IOException and handled by transform
     final File tempDir = createTempDir();
+    INJECTING_HELPERS.begin();
     try {
       return ClassInjector.UsingInstrumentation.of(
               tempDir,
               ClassInjector.UsingInstrumentation.Target.BOOTSTRAP,
               AgentInstaller.getInstrumentation())
           .injectRaw(classnameToBytes);
     } finally {
+      INJECTING_HELPERS.end();
       // Delete fails silently
       deleteTempDir(tempDir);
     }
   }
 
   private Map<String, Class<?>> injectClassLoader(
       final ClassLoader classLoader, final Map<String, byte[]> classnameToBytes) {
-    return new ClassInjector.UsingReflection(classLoader).injectRaw(classnameToBytes);
+    INJECTING_HELPERS.begin();
+    try {
+      return new ClassInjector.UsingReflection(classLoader).injectRaw(classnameToBytes);
+    } finally {
+      INJECTING_HELPERS.end();
+    }
   }
 
   private void ensureModuleCanReadHelperModules(final JavaModule target) {

dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/bytebuddy/DDCachingPoolStrategy.java

@@ -1,5 +1,6 @@
 package datadog.trace.agent.tooling.bytebuddy;
 
+import static datadog.trace.bootstrap.AgentClassLoading.LOCATING_CLASS;
 import static net.bytebuddy.agent.builder.AgentBuilder.PoolStrategy;
 
 import com.googlecode.concurrentlinkedhashmap.ConcurrentLinkedHashMap;
@@ -295,6 +296,7 @@ public TypeDescription resolve() {
       if (!isResolved) {
         Class<?> klass = null;
         ClassLoader classLoader = null;
+        LOCATING_CLASS.begin();
         try {
           // Please note that by doing a loadClass, the type we are resolving will bypass
           // transformation since we are in the middle of a transformation. This should
@@ -310,6 +312,8 @@ public TypeDescription resolve() {
             klass = Class.forName(className, false, null);
           }
         } catch (Throwable ignored) {
+        } finally {
+          LOCATING_CLASS.end();
         }
         if (klass != null) {
           // We managed to load the class

dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/bytebuddy/DDClassFileLocator.java

@@ -0,0 +1,62 @@
+package datadog.trace.agent.tooling.bytebuddy;
+
+import static datadog.trace.bootstrap.AgentClassLoading.LOCATING_CLASS;
+
+import datadog.trace.agent.tooling.Utils;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.ref.WeakReference;
+import net.bytebuddy.dynamic.ClassFileLocator;
+import net.bytebuddy.utility.StreamDrainer;
+
+/**
+ * Locate resources with the loading classloader. Because of a quirk with the way classes appended
+ * to the bootstrap classpath work, we first check our bootstrap proxy. If the loading classloader
+ * cannot find the desired resource, check up the classloader hierarchy until a resource is found.
+ */
+public final class DDClassFileLocator extends WeakReference<ClassLoader>
+    implements ClassFileLocator {
+
+  public DDClassFileLocator(final ClassLoader classLoader) {
+    super(classLoader);
+  }
+
+  @Override
+  public Resolution locate(final String className) throws IOException {
+    String resourceName = className.replace('.', '/') + ".class";
+
+    // try bootstrap first
+    Resolution resolution = loadClassResource(Utils.getBootstrapProxy(), resourceName);
+    ClassLoader cl = get();
+
+    // now go up the classloader hierarchy
+    if (null == resolution && null != cl) {
+      LOCATING_CLASS.begin();
+      try {
+        do {
+          resolution = loadClassResource(cl, resourceName);
+          cl = cl.getParent();
+        } while (null == resolution && null != cl);
+      } finally {
+        LOCATING_CLASS.end();
+      }
+    }
+
+    return resolution != null ? resolution : new Resolution.Illegal(className);
+  }
+
+  @Override
+  public void close() {
+    // nothing to close
+  }
+
+  private static Resolution loadClassResource(
+      final ClassLoader classLoader, final String resourceName) throws IOException {
+    try (InputStream in = classLoader.getResourceAsStream(resourceName)) {
+      if (null != in) {
+        return new Resolution.Explicit(StreamDrainer.DEFAULT.drain(in));
+      }
+      return null;
+    }
+  }
+}

dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/bytebuddy/DDLocationStrategy.java

@@ -1,30 +1,18 @@
 package datadog.trace.agent.tooling.bytebuddy;
 
-import datadog.trace.agent.tooling.Utils;
-import java.util.ArrayList;
-import java.util.List;
 import net.bytebuddy.agent.builder.AgentBuilder;
 import net.bytebuddy.dynamic.ClassFileLocator;
 import net.bytebuddy.utility.JavaModule;
 
-/**
- * Locate resources with the loading classloader. Because of a quirk with the way classes appended
- * to the bootstrap classpath work, we first check our bootstrap proxy. If the loading classloader
- * cannot find the desired resource, check up the classloader hierarchy until a resource is found.
- */
-public class DDLocationStrategy implements AgentBuilder.LocationStrategy {
+/** Strategy that uses {@link DDClassFileLocator} to locate class files. */
+public final class DDLocationStrategy implements AgentBuilder.LocationStrategy {
   public ClassFileLocator classFileLocator(final ClassLoader classLoader) {
     return classFileLocator(classLoader, null);
   }
 
   @Override
-  public ClassFileLocator classFileLocator(ClassLoader classLoader, final JavaModule javaModule) {
-    final List<ClassFileLocator> locators = new ArrayList<>();
-    locators.add(ClassFileLocator.ForClassLoader.of(Utils.getBootstrapProxy()));
-    while (classLoader != null) {
-      locators.add(ClassFileLocator.ForClassLoader.WeaklyReferenced.of(classLoader));
-      classLoader = classLoader.getParent();
-    }
-    return new ClassFileLocator.Compound(locators.toArray(new ClassFileLocator[0]));
+  public ClassFileLocator classFileLocator(
+      final ClassLoader classLoader, final JavaModule javaModule) {
+    return new DDClassFileLocator(classLoader);
   }
 }

dd-java-agent/instrumentation/osgi-4.3/osgi-4.3.gradle

@@ -0,0 +1,21 @@
+muzzle {
+  // old coordinates
+  pass {
+    group = 'org.osgi'
+    module = 'org.osgi.core'
+    versions = '[4.3,]'
+  }
+
+  // new coordinates
+  pass {
+    group = 'org.osgi'
+    module = 'osgi.core'
+    versions = '[4.3.1,]'
+  }
+}
+
+apply from: "$rootDir/gradle/java.gradle"
+
+dependencies {
+  compileOnly group: 'org.osgi', name: 'org.osgi.core', version: '4.3.0'
+}