muzzle field and method matching

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

@@ -99,6 +99,20 @@ public void logrb(
       String msg,
       Throwable thrown) {}
 
+  public void severe(String msg) {}
+
+  public void warning(String msg) {}
+
+  public void info(String msg) {}
+
+  public void config(String msg) {}
+
+  public void fine(String msg) {}
+
+  public void finer(String msg) {}
+
+  public void finest(String msg) {}
+
   public void throwing(String sourceClass, String sourceMethod, Throwable thrown) {}
 
   public void setLevel(Level newLevel) throws SecurityException {}

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

@@ -19,6 +19,7 @@
 
 @Slf4j
 public class AgentInstaller {
+  public static final DDLocationStrategy LOCATION_STRATEGY = new DDLocationStrategy();
   private static volatile Instrumentation INSTRUMENTATION;
 
   public static Instrumentation getInstrumentation() {
@@ -44,7 +45,7 @@ public static ResettableClassFileTransformer installBytebuddyAgent(
             .with(AgentBuilder.RedefinitionStrategy.RETRANSFORMATION)
             .with(AgentBuilder.DescriptionStrategy.Default.POOL_ONLY)
             .with(new LoggingListener())
-            .with(new DDLocationStrategy())
+            .with(LOCATION_STRATEGY)
             .ignore(any(), skipClassLoader())
             .or(nameStartsWith("datadog.trace."))
             .or(nameStartsWith("datadog.opentracing."))

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

@@ -12,6 +12,10 @@
  * reached.
  */
 public class DDLocationStrategy implements AgentBuilder.LocationStrategy {
+  public ClassFileLocator classFileLocator(ClassLoader classLoader) {
+    return classFileLocator(classLoader, null);
+  }
+
   @Override
   public ClassFileLocator classFileLocator(ClassLoader classLoader, final JavaModule javaModule) {
     final List<ClassFileLocator> locators = new ArrayList<>();

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

@@ -128,15 +128,23 @@ public boolean matches(
           final List<Reference.Mismatch> mismatches =
               muzzle.getMismatchedReferenceSources(classLoader);
           if (mismatches.size() > 0) {
+            if (log.isDebugEnabled()) {
+              log.debug(
+                  "Instrumentation muzzled: {} -- {} on {}",
+                  instrumentationPrimaryName,
+                  this.getClass().getName(),
+                  classLoader);
+              for (Reference.Mismatch mismatch : mismatches) {
+                log.debug("-- {}", mismatch);
+              }
+            }
+          } else {
             log.debug(
-                "Instrumentation muzzled: {} -- {} on {}",
+                "Applying instrumentation: {} -- {} on {}",
                 instrumentationPrimaryName,
-                getClass().getName(),
+                this.getClass().getName(),
                 classLoader);
           }
-          for (final Reference.Mismatch mismatch : mismatches) {
-            log.debug("-- {}", mismatch);
-          }
           return mismatches.size() == 0;
         }
         return true;

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

@@ -2,6 +2,7 @@
 
 import datadog.trace.bootstrap.DatadogClassLoader;
 import datadog.trace.bootstrap.DatadogClassLoader.BootstrapClassLoaderProxy;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.URL;
 
@@ -74,6 +75,30 @@ public static String getClassName(final String resourceName) {
     return resourceName.replaceAll("\\.class\\$", "").replace('/', '.');
   }
 
+  /** com.foo.Bar -> com/foo/Bar */
+  public static String getInternalName(final String resourceName) {
+    return resourceName.replaceAll("\\.class\\$", "").replace('.', '/');
+  }
+
+  public static boolean isClassLoaded(final String className, final ClassLoader classLoader) {
+    Class<?> loadedClass = findLoadedClass(className, classLoader);
+    return loadedClass != null && loadedClass.getClassLoader() == classLoader;
+  }
+
+  public static Class<?> findLoadedClass(final String className, ClassLoader classLoader) {
+    if (classLoader == ClassLoaderMatcher.BOOTSTRAP_CLASSLOADER) {
+      classLoader = ClassLoader.getSystemClassLoader();
+    }
+    try {
+      findLoadedClassMethod.setAccessible(true);
+      return (Class<?>) findLoadedClassMethod.invoke(classLoader, className);
+    } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+      throw new IllegalStateException(e);
+    } finally {
+      findLoadedClassMethod.setAccessible(false);
+    }
+  }
+
   static boolean getConfigEnabled(final String name, final boolean fallback) {
     final String property =
         System.getProperty(