Introduce IgnoredTypesConfigurer SPI to enable defining per-module ignores

benchmark/benchmark.gradle

@@ -12,6 +12,8 @@ dependencies {
   jmh "net.bytebuddy:byte-buddy-agent"
 
   jmh project(':instrumentation-api')
+  jmh project(':javaagent-tooling')
+  jmh project(':javaagent-extension-api')
 
   jmh "com.github.ben-manes.caffeine:caffeine"
 

benchmark/src/jmh/java/io/opentelemetry/benchmark/IgnoredTypesMatcherBenchmark.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.benchmark;
+
+import io.opentelemetry.instrumentation.api.config.Config;
+import io.opentelemetry.javaagent.tooling.ignore.AdditionalLibraryIgnoredTypesConfigurer;
+import io.opentelemetry.javaagent.tooling.ignore.IgnoredTypesBuilderImpl;
+import java.util.concurrent.TimeUnit;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.matcher.ElementMatcher;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Warmup;
+
+@Fork(1)
+@Warmup(iterations = 3, time = 1)
+@Measurement(iterations = 10, time = 1)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@BenchmarkMode(Mode.Throughput)
+public class IgnoredTypesMatcherBenchmark {
+
+  private static final TypeDescription springType =
+      new TypeDescription.Latent("org.springframework.test.SomeClass", 0, null);
+  private static final TypeDescription testAppType =
+      new TypeDescription.Latent("com.example.myapp.Main", 0, null);
+
+  private static final ElementMatcher<TypeDescription> ignoredTypesMatcher;
+
+  static {
+    IgnoredTypesBuilderImpl builder = new IgnoredTypesBuilderImpl();
+    new AdditionalLibraryIgnoredTypesConfigurer().configure(Config.get(), builder);
+    ignoredTypesMatcher = builder.buildIgnoredTypesMatcher();
+  }
+
+  @Benchmark
+  public boolean springType() {
+    return ignoredTypesMatcher.matches(springType);
+  }
+
+  @Benchmark
+  public boolean appType() {
+    return ignoredTypesMatcher.matches(testAppType);
+  }
+}

javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/ignore/IgnoredTypesBuilder.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.extension.ignore;
+
+/**
+ * This interface defines different ways to ignore/allow instrumenting classes or packages.
+ *
+ * <p>This interface should not be implemented by the javaagent extension developer - the javaagent
+ * will provide the implementation of all transformations described here.
+ */
+public interface IgnoredTypesBuilder {
+
+  /**
+   * Ignore the class or package specified by {@code classNameOrPrefix} and exclude it from being
+   * instrumented. Calling this will overwrite any previous settings for passed prefix.
+   *
+   * <p>{@code classNameOrPrefix} can be the full class name (ex. {@code com.example.MyClass}),
+   * package name (ex. {@code com.example.mypackage.}), or outer class name (ex {@code
+   * com.example.OuterClass$})
+   *
+   * @return {@code this}
+   */
+  IgnoredTypesBuilder ignoreClass(String classNameOrPrefix);
+
+  /**
+   * Allow the class or package specified by {@code classNameOrPrefix} to be instrumented. Calling
+   * this will overwrite any previous settings for passed prefix.
+   *
+   * <p>{@code classNameOrPrefix} can be the full class name (ex. {@code com.example.MyClass}),
+   * package name (ex. {@code com.example.mypackage.}), or outer class name (ex {@code
+   * com.example.OuterClass$})
+   *
+   * @return {@code this}
+   */
+  IgnoredTypesBuilder allowClass(String classNameOrPrefix);
+
+  /**
+   * Ignore the class loader specified by {@code classNameOrPrefix} and exclude it from being
+   * instrumented. Calling this will overwrite any previous settings for passed prefix.
+   *
+   * <p>{@code classNameOrPrefix} can be the full class name (ex. {@code com.example.MyClass}),
+   * package name (ex. {@code com.example.mypackage.}), or outer class name (ex {@code
+   * com.example.OuterClass$})
+   *
+   * @return {@code this}
+   */
+  IgnoredTypesBuilder ignoreClassLoader(String classNameOrPrefix);
+
+  /**
+   * Allow the class loader specified by {@code classNameOrPrefix} to be instrumented. Calling this
+   * will overwrite any previous settings for passed prefix.
+   *
+   * <p>{@code classNameOrPrefix} can be the full class name (ex. {@code com.example.MyClass}),
+   * package name (ex. {@code com.example.mypackage.}), or outer class name (ex {@code
+   * com.example.OuterClass$})
+   *
+   * @return {@code this}
+   */
+  IgnoredTypesBuilder allowClassLoader(String classNameOrPrefix);
+
+  /**
+   * Ignore the Java concurrent task class specified by {@code classNameOrPrefix} and exclude it
+   * from being instrumented. Concurrent task classes implement or extend one of the following
+   * classes:
+   *
+   * <ul>
+   *   <li>{@link java.lang.Runnable}
+   *   <li>{@link java.util.concurrent.Callable}
+   *   <li>{@link java.util.concurrent.ForkJoinTask}
+   *   <li>{@link java.util.concurrent.Future}
+   * </ul>
+   *
+   * Calling this will overwrite any previous settings for passed prefix.
+   *
+   * <p>{@code classNameOrPrefix} can be the full class name (ex. {@code com.example.MyClass}),
+   * package name (ex. {@code com.example.mypackage.}), or outer class name (ex {@code
+   * com.example.OuterClass$})
+   *
+   * @return {@code this}
+   */
+  IgnoredTypesBuilder ignoreTaskClass(String classNameOrPrefix);
+
+  /**
+   * Allow the Java concurrent task class specified by {@code classNameOrPrefix} to be instrumented.
+   * Concurrent task classes implement or extend one of the following classes:
+   *
+   * <ul>
+   *   <li>{@link java.lang.Runnable}
+   *   <li>{@link java.util.concurrent.Callable}
+   *   <li>{@link java.util.concurrent.ForkJoinTask}
+   *   <li>{@link java.util.concurrent.Future}
+   * </ul>
+   *
+   * Calling this will overwrite any previous settings for passed prefix.
+   *
+   * <p>{@code classNameOrPrefix} can be the full class name (ex. {@code com.example.MyClass}),
+   * package name (ex. {@code com.example.mypackage.}), or outer class name (ex {@code
+   * com.example.OuterClass$})
+   *
+   * @return {@code this}
+   */
+  IgnoredTypesBuilder allowTaskClass(String classNameOrPrefix);
+}

javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/ignore/IgnoredTypesConfigurer.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.extension.ignore;
+
+import io.opentelemetry.instrumentation.api.config.Config;
+import io.opentelemetry.javaagent.extension.Ordered;
+
+/**
+ * An {@link IgnoredTypesConfigurer} can be used to override built-in instrumentation restrictions:
+ * ignore some classes and exclude them from being instrumented, or explicitly allow them to be
+ * instrumented if the agent ignored them by default.
+ *
+ * <p>This is a service provider interface that requires implementations to be registered in a
+ * provider-configuration file stored in the {@code META-INF/services} resource directory.
+ */
+public interface IgnoredTypesConfigurer extends Ordered {
+
+  /**
+   * Configure the passed {@code builder} and define which classes should be ignored when
+   * instrumenting.
+   */
+  void configure(Config config, IgnoredTypesBuilder builder);
+}

javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/spi/IgnoreMatcherProvider.java

@@ -16,7 +16,11 @@
  *
  * <p>This is a service provider interface that requires implementations to be registered in {@code
  * META-INF/services} folder. Only a single implementation of this SPI can be provided.
+ *
+ * @deprecated Please use {@link io.opentelemetry.javaagent.extension.ignore.IgnoredTypesConfigurer}
+ *     instead.
  */
+@Deprecated
 public interface IgnoreMatcherProvider {
 
   /**

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

@@ -17,12 +17,14 @@
 import io.opentelemetry.javaagent.bootstrap.AgentClassLoader;
 import io.opentelemetry.javaagent.extension.AgentExtension;
 import io.opentelemetry.javaagent.extension.AgentListener;
+import io.opentelemetry.javaagent.extension.ignore.IgnoredTypesConfigurer;
 import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule;
 import io.opentelemetry.javaagent.instrumentation.api.internal.BootstrapPackagePrefixesHolder;
 import io.opentelemetry.javaagent.spi.BootstrapPackagesProvider;
 import io.opentelemetry.javaagent.spi.IgnoreMatcherProvider;
 import io.opentelemetry.javaagent.tooling.config.ConfigInitializer;
 import io.opentelemetry.javaagent.tooling.context.FieldBackedProvider;
+import io.opentelemetry.javaagent.tooling.ignore.IgnoredTypesBuilderImpl;
 import io.opentelemetry.javaagent.tooling.matcher.GlobalClassloaderIgnoresMatcher;
 import java.lang.instrument.Instrumentation;
 import java.lang.reflect.Proxy;
@@ -62,12 +64,6 @@ public class AgentInstaller {
   private static final String FORCE_SYNCHRONOUS_AGENT_LISTENERS_CONFIG =
       "otel.javaagent.experimental.force-synchronous-agent-listeners";
 
-  // We set this system property when running the agent with unit tests to allow verifying that we
-  // don't ignore libraries that we actually attempt to instrument. It means either the list is
-  // wrong or a type matcher is.
-  private static final String ADDITIONAL_LIBRARY_IGNORES_ENABLED =
-      "otel.javaagent.testing.additional-library-ignores.enabled";
-
   private static final Map<String, List<Runnable>> CLASS_LOAD_CALLBACKS = new HashMap<>();
   private static volatile Instrumentation instrumentation;
 
@@ -140,9 +136,7 @@ public static ResettableClassFileTransformer installBytebuddyAgent(
 
     ignoredAgentBuilder =
         ignoredAgentBuilder.or(
-            globalIgnoresMatcher(
-                config.getBooleanProperty(ADDITIONAL_LIBRARY_IGNORES_ENABLED, true),
-                ignoreMatcherProvider));
+            globalIgnoresMatcher(ignoreMatcherProvider, loadIgnoredTypesMatcher(config)));
 
     ignoredAgentBuilder = ignoredAgentBuilder.or(matchesConfiguredExcludes());
 
@@ -180,6 +174,14 @@ public static ResettableClassFileTransformer installBytebuddyAgent(
     return resettableClassFileTransformer;
   }
 
+  private static ElementMatcher<TypeDescription> loadIgnoredTypesMatcher(Config config) {
+    IgnoredTypesBuilderImpl ignoredTypesBuilder = new IgnoredTypesBuilderImpl();
+    for (IgnoredTypesConfigurer configurer : loadOrdered(IgnoredTypesConfigurer.class)) {
+      configurer.configure(config, ignoredTypesBuilder);
+    }
+    return ignoredTypesBuilder.buildIgnoredTypesMatcher();
+  }
+
   private static void runBeforeAgentListeners(
       Iterable<AgentListener> agentListeners, Config config) {
     for (AgentListener agentListener : agentListeners) {
@@ -248,6 +250,7 @@ private static void addByteBuddyRawSetting() {
     }
   }
 
+  // TODO: rewrite to an IgnoredTypesConfigurer
   private static ElementMatcher.Junction<? super TypeDescription> matchesConfiguredExcludes() {
     List<String> excludedClasses = Config.get().getListProperty(EXCLUDED_CLASSES_CONFIG);
     ElementMatcher.Junction<? super TypeDescription> matcher = none();