diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/completablefuture/AsyncTaskInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/completablefuture/AsyncTaskInstrumentation.java index 59a2c50ef26..676f6607797 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/completablefuture/AsyncTaskInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/completablefuture/AsyncTaskInstrumentation.java @@ -8,17 +8,14 @@ import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType.RUNNABLE; import static net.bytebuddy.matcher.ElementMatchers.isConstructor; -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.ExcludeFilterProvider; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.api.AgentScope; import datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter; import datadog.trace.bootstrap.instrumentation.java.concurrent.State; import java.util.Arrays; import java.util.Collection; -import java.util.Collections; import java.util.EnumMap; import java.util.Map; import java.util.concurrent.ForkJoinTask; @@ -30,8 +27,7 @@ * either context. This double instrumentation otherwise leads to excess scope creation and * duplicate checkpoint emission. */ -@AutoService(InstrumenterModule.class) -public final class AsyncTaskInstrumentation extends InstrumenterModule.Tracing +public final class AsyncTaskInstrumentation implements Instrumenter.ForBootstrap, Instrumenter.ForKnownTypes, Instrumenter.HasMethodAdvice, @@ -42,20 +38,11 @@ public final class AsyncTaskInstrumentation extends InstrumenterModule.Tracing "java.util.concurrent.CompletableFuture$AsyncRun", }; - public AsyncTaskInstrumentation() { - super("java_completablefuture", "java_concurrent"); - } - @Override public String[] knownMatchingTypes() { return CLASS_NAMES; } - @Override - public Map contextStore() { - return Collections.singletonMap("java.util.concurrent.ForkJoinTask", State.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice(isConstructor(), getClass().getName() + "$Construct"); diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/completablefuture/CompletableFutureModule.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/completablefuture/CompletableFutureModule.java new file mode 100644 index 00000000000..07b302d419f --- /dev/null +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/completablefuture/CompletableFutureModule.java @@ -0,0 +1,37 @@ +package datadog.trace.instrumentation.java.completablefuture; + +import com.google.auto.service.AutoService; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import datadog.trace.bootstrap.instrumentation.java.concurrent.ConcurrentState; +import datadog.trace.bootstrap.instrumentation.java.concurrent.State; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** Groups the instrumentations for CompletableFuture and related classes. */ +@AutoService(InstrumenterModule.class) +public final class CompletableFutureModule extends InstrumenterModule.Tracing { + + public CompletableFutureModule() { + super("java_completablefuture", "java_concurrent"); + } + + @Override + public Map contextStore() { + Map stores = new HashMap<>(); + stores.put("java.util.concurrent.ForkJoinTask", State.class.getName()); + stores.put( + "java.util.concurrent.CompletableFuture$UniCompletion", ConcurrentState.class.getName()); + return stores; + } + + @Override + public List typeInstrumentations() { + return Arrays.asList( + new AsyncTaskInstrumentation(), + new CompletableFutureUniCompletionInstrumentation(), + new CompletableFutureUniCompletionSubclassInstrumentation()); + } +} diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/completablefuture/CompletableFutureUniCompletionInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/completablefuture/CompletableFutureUniCompletionInstrumentation.java index 659a0e53706..607f105571c 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/completablefuture/CompletableFutureUniCompletionInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/completablefuture/CompletableFutureUniCompletionInstrumentation.java @@ -3,18 +3,14 @@ import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType.EXECUTOR; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType.FORK_JOIN_TASK; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType.RUNNABLE; -import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.isConstructor; -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.ExcludeFilterProvider; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.instrumentation.java.concurrent.ConcurrentState; import datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType; import java.util.Arrays; import java.util.Collection; -import java.util.Collections; import java.util.EnumMap; import java.util.List; import java.util.Map; @@ -30,7 +26,7 @@ * f.thenApplyAsync({ r -> ... }) * } * - * The general idea is to capture the current scope at the time of creation of the {@code + *

The general idea is to capture the current scope at the time of creation of the {@code * UniCompletion} and then activate that scope around the processing that happens in the {@code * tryFire} method. * @@ -45,8 +41,7 @@ * continuation {@code ConcurrentContinuation}, have been introduced to deal with the benign race * taking place that decides which thread actually get to run the user code that was supplied. */ -@AutoService(InstrumenterModule.class) -public class CompletableFutureUniCompletionInstrumentation extends InstrumenterModule.Tracing +public class CompletableFutureUniCompletionInstrumentation implements Instrumenter.ForBootstrap, Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice, @@ -56,20 +51,11 @@ public class CompletableFutureUniCompletionInstrumentation extends InstrumenterM static final String UNI_COMPLETION = COMPLETABLE_FUTURE + "$UniCompletion"; static final String ADVICE_BASE = JAVA_UTIL_CONCURRENT + ".CompletableFutureAdvice$"; - public CompletableFutureUniCompletionInstrumentation() { - super("java_completablefuture", "java_concurrent"); - } - @Override public String instrumentedType() { return UNI_COMPLETION; } - @Override - public Map contextStore() { - return singletonMap(UNI_COMPLETION, ConcurrentState.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice(isConstructor(), ADVICE_BASE + "UniConstructor"); @@ -77,9 +63,6 @@ public void methodAdvice(MethodTransformer transformer) { @Override public Map> excludedClasses() { - if (!isEnabled()) { - return Collections.emptyMap(); - } String[] classes = { // This is not a subclass of UniCompletion and doesn't have a dependent CompletableFuture "java.util.concurrent.CompletableFuture$Completion", diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/completablefuture/CompletableFutureUniCompletionSubclassInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/completablefuture/CompletableFutureUniCompletionSubclassInstrumentation.java index 8cb121852fe..c2b8175d13e 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/completablefuture/CompletableFutureUniCompletionSubclassInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/completablefuture/CompletableFutureUniCompletionSubclassInstrumentation.java @@ -4,29 +4,18 @@ import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.nameStartsWith; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; import static datadog.trace.instrumentation.java.completablefuture.CompletableFutureUniCompletionInstrumentation.*; -import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.takesArguments; -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; -import datadog.trace.bootstrap.instrumentation.java.concurrent.ConcurrentState; -import java.util.Map; import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.matcher.ElementMatcher; /** Described in {@link CompletableFutureUniCompletionInstrumentation} */ -@AutoService(InstrumenterModule.class) -public class CompletableFutureUniCompletionSubclassInstrumentation - extends InstrumenterModule.Tracing +public final class CompletableFutureUniCompletionSubclassInstrumentation implements Instrumenter.ForBootstrap, Instrumenter.ForTypeHierarchy, Instrumenter.HasMethodAdvice { - public CompletableFutureUniCompletionSubclassInstrumentation() { - super("java_completablefuture", "java_concurrent"); - } - @Override public String hierarchyMarkerType() { return null; // bootstrap type @@ -37,11 +26,6 @@ public ElementMatcher hierarchyMatcher() { return nameStartsWith(COMPLETABLE_FUTURE).and(extendsClass(named(UNI_COMPLETION))); } - @Override - public Map contextStore() { - return singletonMap(UNI_COMPLETION, ConcurrentState.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice( diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/AsyncPropagatingDisableInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/AsyncPropagatingDisableInstrumentation.java index 16564f1123b..1ce9873ed65 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/AsyncPropagatingDisableInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/AsyncPropagatingDisableInstrumentation.java @@ -7,13 +7,10 @@ import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.namedOneOf; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.isAsyncPropagationEnabled; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.setAsyncPropagationEnabled; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; import static net.bytebuddy.matcher.ElementMatchers.isDeclaredBy; import static net.bytebuddy.matcher.ElementMatchers.isTypeInitializer; -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import net.bytebuddy.asm.Advice; import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.matcher.ElementMatcher; @@ -23,14 +20,9 @@ * it can cause the trace to never be reported. Add matchers below to disable async propagation * during this period. */ -@AutoService(InstrumenterModule.class) -public final class AsyncPropagatingDisableInstrumentation extends InstrumenterModule.Tracing +public final class AsyncPropagatingDisableInstrumentation implements Instrumenter.CanShortcutTypeMatching, Instrumenter.HasMethodAdvice { - public AsyncPropagatingDisableInstrumentation() { - super(EXECUTOR_INSTRUMENTATION_NAME); - } - private static final ElementMatcher.Junction RX_WORKERS = nameStartsWith("rx.").and(extendsClass(named("rx.Scheduler$Worker"))); private static final ElementMatcher NETTY_UNSAFE = diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/ExecutorModule.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/ExecutorModule.java new file mode 100644 index 00000000000..b041b2e025d --- /dev/null +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/ExecutorModule.java @@ -0,0 +1,54 @@ +package datadog.trace.instrumentation.java.concurrent; + +import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; +import static datadog.trace.instrumentation.java.concurrent.executor.ThreadPoolExecutorInstrumentation.TPE; +import static java.util.Collections.singleton; + +import com.google.auto.service.AutoService; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import datadog.trace.api.InstrumenterConfig; +import datadog.trace.bootstrap.instrumentation.java.concurrent.State; +import datadog.trace.instrumentation.java.concurrent.executor.JavaExecutorInstrumentation; +import datadog.trace.instrumentation.java.concurrent.executor.NonStandardExecutorInstrumentation; +import datadog.trace.instrumentation.java.concurrent.executor.RejectedExecutionHandlerInstrumentation; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.RunnableFuture; + +@AutoService(InstrumenterModule.class) +public class ExecutorModule extends InstrumenterModule.Tracing { + public ExecutorModule() { + super(EXECUTOR_INSTRUMENTATION_NAME); + } + + @Override + public Map contextStore() { + final Map contextStore = new HashMap<>(); + contextStore.put(Runnable.class.getName(), State.class.getName()); + contextStore.put(TPE, Boolean.class.getName()); + contextStore.put(RunnableFuture.class.getName(), State.class.getName()); + return contextStore; + } + + @Override + public List typeInstrumentations() { + final List instrumenters = new ArrayList<>(5); + final InstrumenterConfig config = InstrumenterConfig.get(); + instrumenters.add(new AsyncPropagatingDisableInstrumentation()); + if (InstrumenterConfig.get().isIntegrationEnabled(singleton("new-task-for"), true)) { + instrumenters.add(new WrapRunnableAsNewTaskInstrumentation()); + } + instrumenters.add(new JavaExecutorInstrumentation()); + if (config.isIntegrationEnabled(singleton(EXECUTOR_INSTRUMENTATION_NAME + ".other"), true)) { + instrumenters.add(new NonStandardExecutorInstrumentation()); + } + if (config.isIntegrationEnabled(singleton("rejected-execution-handler"), true)) { + instrumenters.add(new RejectedExecutionHandlerInstrumentation()); + } + + return instrumenters; + } +} diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/ProfilingQueuingModule.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/ProfilingQueuingModule.java new file mode 100644 index 00000000000..b07b0d1b5fb --- /dev/null +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/ProfilingQueuingModule.java @@ -0,0 +1,44 @@ +package datadog.trace.instrumentation.java.concurrent; + +import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; +import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.FORK_JOIN_POOL_INSTRUMENTATION_NAME; +import static java.util.Collections.singleton; + +import com.google.auto.service.AutoService; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import datadog.trace.api.InstrumenterConfig; +import datadog.trace.api.config.ProfilingConfig; +import datadog.trace.bootstrap.config.provider.ConfigProvider; +import datadog.trace.instrumentation.java.concurrent.forkjoin.JavaForkJoinWorkQueueInstrumentation; +import java.util.ArrayList; +import java.util.List; + +@AutoService(InstrumenterModule.class) +public class ProfilingQueuingModule extends InstrumenterModule.Profiling { + public ProfilingQueuingModule() { + super(EXECUTOR_INSTRUMENTATION_NAME); + } + + @Override + public boolean isEnabled() { + return super.isEnabled() + && ConfigProvider.getInstance() + .getBoolean( + ProfilingConfig.PROFILING_QUEUEING_TIME_ENABLED, + ProfilingConfig.PROFILING_QUEUEING_TIME_ENABLED_DEFAULT); + } + + @Override + public List typeInstrumentations() { + final List instrumenters = new ArrayList<>(2); + final InstrumenterConfig config = InstrumenterConfig.get(); + if (config.isIntegrationEnabled(singleton(FORK_JOIN_POOL_INSTRUMENTATION_NAME), true)) { + instrumenters.add(new JavaForkJoinWorkQueueInstrumentation()); + } + if (config.isIntegrationEnabled(singleton("task-unwrapping"), true)) { + instrumenters.add(new TaskUnwrappingInstrumentation()); + } + return instrumenters; + } +} diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/TaskUnwrappingInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/TaskUnwrappingInstrumentation.java index 01e810a9875..82e01ff585f 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/TaskUnwrappingInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/TaskUnwrappingInstrumentation.java @@ -1,29 +1,10 @@ package datadog.trace.instrumentation.java.concurrent; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; - -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.agent.tooling.bytebuddy.profiling.UnwrappingVisitor; -import datadog.trace.api.config.ProfilingConfig; -import datadog.trace.bootstrap.config.provider.ConfigProvider; -@AutoService(InstrumenterModule.class) -public class TaskUnwrappingInstrumentation extends InstrumenterModule.Profiling +public class TaskUnwrappingInstrumentation implements Instrumenter.ForKnownTypes, Instrumenter.HasTypeAdvice { - public TaskUnwrappingInstrumentation() { - super(EXECUTOR_INSTRUMENTATION_NAME, "task-unwrapping"); - } - - @Override - public boolean isEnabled() { - return super.isEnabled() - && ConfigProvider.getInstance() - .getBoolean( - ProfilingConfig.PROFILING_QUEUEING_TIME_ENABLED, - ProfilingConfig.PROFILING_QUEUEING_TIME_ENABLED_DEFAULT); - } private static final String[] TYPES_WITH_FIELDS = { "java.util.concurrent.FutureTask", diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/WrapRunnableAsNewTaskInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/WrapRunnableAsNewTaskInstrumentation.java index 48428a07703..9500017e724 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/WrapRunnableAsNewTaskInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/WrapRunnableAsNewTaskInstrumentation.java @@ -4,15 +4,12 @@ import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType.RUNNABLE; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.exclude; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; import static net.bytebuddy.matcher.ElementMatchers.isDeclaredBy; import static net.bytebuddy.matcher.ElementMatchers.isMethod; import static net.bytebuddy.matcher.ElementMatchers.not; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.instrumentation.java.concurrent.NewTaskForPlaceholder; import datadog.trace.bootstrap.instrumentation.java.concurrent.Wrapper; import java.util.concurrent.AbstractExecutorService; @@ -22,12 +19,8 @@ import net.bytebuddy.description.method.MethodDescription; import net.bytebuddy.matcher.ElementMatcher.Junction; -@AutoService(InstrumenterModule.class) -public final class WrapRunnableAsNewTaskInstrumentation extends InstrumenterModule.Tracing +public final class WrapRunnableAsNewTaskInstrumentation implements Instrumenter.ForBootstrap, Instrumenter.ForKnownTypes, Instrumenter.HasMethodAdvice { - public WrapRunnableAsNewTaskInstrumentation() { - super(EXECUTOR_INSTRUMENTATION_NAME, "new-task-for"); - } @Override public String[] knownMatchingTypes() { diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/AbstractExecutorInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/AbstractExecutorInstrumentation.java index 096055f2658..7489bf11a98 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/AbstractExecutorInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/AbstractExecutorInstrumentation.java @@ -2,10 +2,8 @@ import static datadog.trace.agent.tooling.bytebuddy.matcher.HierarchyMatchers.implementsInterface; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.api.InstrumenterConfig; import java.util.Collection; import java.util.concurrent.Executor; @@ -14,7 +12,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public abstract class AbstractExecutorInstrumentation extends InstrumenterModule.Tracing +public abstract class AbstractExecutorInstrumentation implements Instrumenter.ForBootstrap, Instrumenter.CanShortcutTypeMatching, Instrumenter.ForConfiguredTypes, @@ -25,8 +23,7 @@ public abstract class AbstractExecutorInstrumentation extends InstrumenterModule /** To apply to all executors, use override setting below. */ private final boolean TRACE_ALL_EXECUTORS = InstrumenterConfig.get().isTraceExecutorsAll(); - public AbstractExecutorInstrumentation(final String... additionalNames) { - super(EXECUTOR_INSTRUMENTATION_NAME, additionalNames); + public AbstractExecutorInstrumentation() { if (TRACE_ALL_EXECUTORS) { log.warn("Tracing all executors enabled. This is not a recommended setting."); diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/JavaExecutorInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/JavaExecutorInstrumentation.java index 4634c23dc9a..7d5d6f3807f 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/JavaExecutorInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/JavaExecutorInstrumentation.java @@ -5,27 +5,17 @@ import static net.bytebuddy.matcher.ElementMatchers.takesArgument; import static net.bytebuddy.matcher.ElementMatchers.takesArguments; -import com.google.auto.service.AutoService; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.ContextStore; import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.api.AgentSpan; import datadog.trace.bootstrap.instrumentation.java.concurrent.ExecutorInstrumentationUtils; import datadog.trace.bootstrap.instrumentation.java.concurrent.RunnableWrapper; import datadog.trace.bootstrap.instrumentation.java.concurrent.State; -import java.util.Collections; -import java.util.Map; import java.util.concurrent.RunnableFuture; import net.bytebuddy.asm.Advice; -@AutoService(InstrumenterModule.class) public final class JavaExecutorInstrumentation extends AbstractExecutorInstrumentation { - @Override - public Map contextStore() { - return Collections.singletonMap(Runnable.class.getName(), State.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice( diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/NonStandardExecutorInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/NonStandardExecutorInstrumentation.java index fc89f66afc9..c29752daff2 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/NonStandardExecutorInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/NonStandardExecutorInstrumentation.java @@ -1,28 +1,10 @@ package datadog.trace.instrumentation.java.concurrent.executor; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; -import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; import static net.bytebuddy.matcher.ElementMatchers.takesArguments; -import com.google.auto.service.AutoService; -import datadog.trace.agent.tooling.InstrumenterModule; -import datadog.trace.bootstrap.instrumentation.java.concurrent.State; -import java.util.Map; - -@AutoService(InstrumenterModule.class) public final class NonStandardExecutorInstrumentation extends AbstractExecutorInstrumentation { - - public NonStandardExecutorInstrumentation() { - super(EXECUTOR_INSTRUMENTATION_NAME + ".other"); - } - - @Override - public Map contextStore() { - return singletonMap(Runnable.class.getName(), State.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice( // kotlinx.coroutines.scheduling.CoroutineScheduler diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/RejectedExecutionHandlerInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/RejectedExecutionHandlerInstrumentation.java index 32329ca62d1..a3b8902e1f5 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/RejectedExecutionHandlerInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/RejectedExecutionHandlerInstrumentation.java @@ -6,38 +6,32 @@ import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.namedOneOf; import static datadog.trace.bootstrap.instrumentation.java.concurrent.AdviceUtils.cancelTask; import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; +import static java.util.Arrays.asList; import static net.bytebuddy.matcher.ElementMatchers.isMethod; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.api.Config; +import datadog.trace.api.InstrumenterConfig; import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.java.concurrent.State; import datadog.trace.bootstrap.instrumentation.java.concurrent.Wrapper; import datadog.trace.bootstrap.instrumentation.jfr.backpressure.BackpressureProfiling; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; import java.util.concurrent.RunnableFuture; import net.bytebuddy.asm.Advice; import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.matcher.ElementMatcher; -@AutoService(InstrumenterModule.class) -public class RejectedExecutionHandlerInstrumentation extends InstrumenterModule.Tracing +public class RejectedExecutionHandlerInstrumentation implements Instrumenter.ForBootstrap, Instrumenter.CanShortcutTypeMatching, Instrumenter.HasMethodAdvice { - public RejectedExecutionHandlerInstrumentation() { - super(EXECUTOR_INSTRUMENTATION_NAME, "rejected-execution-handler"); - } - @Override public boolean onlyMatchKnownTypes() { - return isShortcutMatchingEnabled(false); + return InstrumenterConfig.get() + .isIntegrationShortcutMatchingEnabled( + asList(EXECUTOR_INSTRUMENTATION_NAME, "rejected-execution-handler"), false); } @Override @@ -62,15 +56,6 @@ public ElementMatcher hierarchyMatcher() { .or(nameEndsWith("netty.util.concurrent.RejectedExecutionHandler"))); } - @Override - public Map contextStore() { - Map contextStore = new HashMap<>(4); - contextStore.put("java.util.concurrent.RunnableFuture", State.class.getName()); - // TODO get rid of this - contextStore.put("java.lang.Runnable", State.class.getName()); - return Collections.unmodifiableMap(contextStore); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice( diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/ThreadPoolExecutorInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/ThreadPoolExecutorInstrumentation.java index f3f37e71ec6..6b6d1b3b782 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/ThreadPoolExecutorInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/ThreadPoolExecutorInstrumentation.java @@ -7,7 +7,6 @@ import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType.RUNNABLE; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType.RUNNABLE_FUTURE; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.exclude; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; import static net.bytebuddy.matcher.ElementMatchers.isConstructor; import static net.bytebuddy.matcher.ElementMatchers.isDeclaredBy; import static net.bytebuddy.matcher.ElementMatchers.isMethod; @@ -15,10 +14,8 @@ import static net.bytebuddy.matcher.ElementMatchers.returns; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.ExcludeFilterProvider; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.api.Platform; import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.api.AgentScope; @@ -64,14 +61,13 @@ * <- + close AgentScope if available * } */ -@AutoService(InstrumenterModule.class) -public final class ThreadPoolExecutorInstrumentation extends InstrumenterModule.Tracing +public final class ThreadPoolExecutorInstrumentation implements Instrumenter.ForBootstrap, Instrumenter.ForTypeHierarchy, Instrumenter.HasMethodAdvice, ExcludeFilterProvider { - private static final String TPE = "java.util.concurrent.ThreadPoolExecutor"; + public static final String TPE = "java.util.concurrent.ThreadPoolExecutor"; // executors which do their own wrapping before calling super, // leading to double wrapping, once at the child level and once @@ -81,10 +77,6 @@ public final class ThreadPoolExecutorInstrumentation extends InstrumenterModule. isDeclaredBy( namedOneOf("org.elasticsearch.common.util.concurrent.EsThreadPoolExecutor"))); - public ThreadPoolExecutorInstrumentation() { - super(EXECUTOR_INSTRUMENTATION_NAME); - } - @Override public String hierarchyMarkerType() { return null; // bootstrap type @@ -96,15 +88,6 @@ public ElementMatcher hierarchyMatcher() { .and(extendsClass(named(TPE))); } - @Override - public Map contextStore() { - final Map stores = new HashMap<>(); - stores.put(TPE, Boolean.class.getName()); - stores.put(Runnable.class.getName(), State.class.getName()); - stores.put(RunnableFuture.class.getName(), State.class.getName()); - return Collections.unmodifiableMap(stores); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice(isConstructor(), getClass().getName() + "$Init"); diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/forkjoin/ForkJoinModule.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/forkjoin/ForkJoinModule.java new file mode 100644 index 00000000000..6d0f48b3d6f --- /dev/null +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/forkjoin/ForkJoinModule.java @@ -0,0 +1,34 @@ +package datadog.trace.instrumentation.java.concurrent.forkjoin; + +import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; +import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.FORK_JOIN_POOL_INSTRUMENTATION_NAME; + +import com.google.auto.service.AutoService; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import datadog.trace.bootstrap.instrumentation.java.concurrent.State; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +/** Groups the instrumentations for ForkJoinPool, ForkJoinTask, and WorkQueue. */ +@AutoService(InstrumenterModule.class) +public final class ForkJoinModule extends InstrumenterModule.Tracing { + public ForkJoinModule() { + super(EXECUTOR_INSTRUMENTATION_NAME, FORK_JOIN_POOL_INSTRUMENTATION_NAME); + } + + @Override + public Map contextStore() { + return Collections.singletonMap("java.util.concurrent.ForkJoinTask", State.class.getName()); + } + + @Override + public List typeInstrumentations() { + List instrumenters = new ArrayList<>(2); + instrumenters.add(new JavaForkJoinPoolInstrumentation()); + instrumenters.add(new JavaForkJoinTaskInstrumentation()); + return instrumenters; + } +} diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/forkjoin/JavaForkJoinPoolInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/forkjoin/JavaForkJoinPoolInstrumentation.java index 24d39e04168..c6f37e4687d 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/forkjoin/JavaForkJoinPoolInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/forkjoin/JavaForkJoinPoolInstrumentation.java @@ -6,39 +6,23 @@ import static datadog.trace.bootstrap.instrumentation.java.concurrent.AdviceUtils.capture; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType.FORK_JOIN_TASK; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.exclude; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.FORK_JOIN_POOL_INSTRUMENTATION_NAME; -import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.isMethod; -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.ContextStore; import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.java.concurrent.State; -import java.util.Map; import java.util.concurrent.ForkJoinTask; import net.bytebuddy.asm.Advice; -@AutoService(InstrumenterModule.class) -public class JavaForkJoinPoolInstrumentation extends InstrumenterModule.Tracing +public final class JavaForkJoinPoolInstrumentation implements Instrumenter.ForBootstrap, Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public JavaForkJoinPoolInstrumentation() { - super(EXECUTOR_INSTRUMENTATION_NAME, FORK_JOIN_POOL_INSTRUMENTATION_NAME); - } - @Override public String instrumentedType() { return "java.util.concurrent.ForkJoinPool"; } - @Override - public Map contextStore() { - return singletonMap("java.util.concurrent.ForkJoinTask", State.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { String name = getClass().getName(); diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/forkjoin/JavaForkJoinTaskInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/forkjoin/JavaForkJoinTaskInstrumentation.java index 447584019a6..b5552130b49 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/forkjoin/JavaForkJoinTaskInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/forkjoin/JavaForkJoinTaskInstrumentation.java @@ -11,15 +11,11 @@ import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType.FORK_JOIN_TASK; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType.RUNNABLE_FUTURE; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.exclude; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.FORK_JOIN_POOL_INSTRUMENTATION_NAME; import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.isMethod; -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.ExcludeFilterProvider; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.api.AgentScope; import datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType; @@ -38,17 +34,12 @@ *

Note: There are quite a few separate implementations of {@code ForkJoinTask}/{@code * ForkJoinPool}: JVM, Akka, Scala, Netty to name a few. This class handles JVM version. */ -@AutoService(InstrumenterModule.class) -public final class JavaForkJoinTaskInstrumentation extends InstrumenterModule.Tracing +public final class JavaForkJoinTaskInstrumentation implements Instrumenter.ForBootstrap, Instrumenter.ForTypeHierarchy, Instrumenter.HasMethodAdvice, ExcludeFilterProvider { - public JavaForkJoinTaskInstrumentation() { - super(EXECUTOR_INSTRUMENTATION_NAME, FORK_JOIN_POOL_INSTRUMENTATION_NAME); - } - @Override public String hierarchyMarkerType() { return null; // bootstrap type @@ -61,11 +52,6 @@ public ElementMatcher hierarchyMatcher() { .and(extendsClass(named("java.util.concurrent.ForkJoinTask"))); } - @Override - public Map contextStore() { - return singletonMap("java.util.concurrent.ForkJoinTask", State.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice( diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/forkjoin/JavaForkJoinWorkQueueInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/forkjoin/JavaForkJoinWorkQueueInstrumentation.java index 3be741c9908..bd1f081f623 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/forkjoin/JavaForkJoinWorkQueueInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/forkjoin/JavaForkJoinWorkQueueInstrumentation.java @@ -4,58 +4,28 @@ import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType.FORK_JOIN_TASK; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.exclude; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.FORK_JOIN_POOL_INSTRUMENTATION_NAME; -import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.fieldType; import static net.bytebuddy.matcher.ElementMatchers.isDeclaredBy; import static net.bytebuddy.matcher.ElementMatchers.isMethod; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; -import datadog.trace.api.config.ProfilingConfig; import datadog.trace.bootstrap.ContextStore; import datadog.trace.bootstrap.InstrumentationContext; -import datadog.trace.bootstrap.config.provider.ConfigProvider; import datadog.trace.bootstrap.instrumentation.java.concurrent.QueueTimerHelper; import datadog.trace.bootstrap.instrumentation.java.concurrent.State; -import java.util.Map; import java.util.concurrent.ForkJoinPool; import java.util.concurrent.ForkJoinTask; import net.bytebuddy.asm.Advice; -@AutoService(InstrumenterModule.class) -public class JavaForkJoinWorkQueueInstrumentation extends InstrumenterModule.Profiling +public final class JavaForkJoinWorkQueueInstrumentation implements Instrumenter.ForBootstrap, Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public JavaForkJoinWorkQueueInstrumentation() { - super( - EXECUTOR_INSTRUMENTATION_NAME, - FORK_JOIN_POOL_INSTRUMENTATION_NAME, - FORK_JOIN_POOL_INSTRUMENTATION_NAME + "-workqueue"); - } - @Override public String instrumentedType() { return "java.util.concurrent.ForkJoinPool$WorkQueue"; } - @Override - public boolean isEnabled() { - return super.isEnabled() - && ConfigProvider.getInstance() - .getBoolean( - ProfilingConfig.PROFILING_QUEUEING_TIME_ENABLED, - ProfilingConfig.PROFILING_QUEUEING_TIME_ENABLED_DEFAULT); - } - - @Override - public Map contextStore() { - return singletonMap("java.util.concurrent.ForkJoinTask", State.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { String name = getClass().getName(); diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/runnable/ConsumerTaskInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/runnable/ConsumerTaskInstrumentation.java index a4ecfa779a3..d4db09858c1 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/runnable/ConsumerTaskInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/runnable/ConsumerTaskInstrumentation.java @@ -4,18 +4,13 @@ import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; import static datadog.trace.bootstrap.instrumentation.java.concurrent.AdviceUtils.endTaskScope; import static datadog.trace.bootstrap.instrumentation.java.concurrent.AdviceUtils.startTaskScope; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; -import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.isConstructor; -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.api.AgentScope; import datadog.trace.bootstrap.instrumentation.api.AgentSpan; import datadog.trace.bootstrap.instrumentation.java.concurrent.State; -import java.util.Map; import java.util.concurrent.ForkJoinTask; import net.bytebuddy.asm.Advice; @@ -24,23 +19,14 @@ * parent class is already instrumented by {@link * datadog.trace.instrumentation.java.concurrent.forkjoin.JavaForkJoinTaskInstrumentation} */ -@AutoService(InstrumenterModule.class) -public class ConsumerTaskInstrumentation extends InstrumenterModule.Tracing +public class ConsumerTaskInstrumentation implements Instrumenter.ForBootstrap, Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public ConsumerTaskInstrumentation() { - super(EXECUTOR_INSTRUMENTATION_NAME, "consumer-task"); - } @Override public String instrumentedType() { return "java.util.concurrent.SubmissionPublisher$ConsumerTask"; } - @Override - public Map contextStore() { - return singletonMap("java.util.concurrent.ForkJoinTask", State.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice(isConstructor(), getClass().getName() + "$Construct"); diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/runnable/RunnableFutureInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/runnable/RunnableFutureInstrumentation.java index a28711a9fdb..b53e7be7817 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/runnable/RunnableFutureInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/runnable/RunnableFutureInstrumentation.java @@ -11,17 +11,14 @@ import static datadog.trace.bootstrap.instrumentation.java.concurrent.AdviceUtils.startTaskScope; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType.RUNNABLE; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType.RUNNABLE_FUTURE; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.isConstructor; import static net.bytebuddy.matcher.ElementMatchers.isDeclaredBy; import static net.bytebuddy.matcher.ElementMatchers.isMethod; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.ExcludeFilterProvider; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.api.AgentScope; import datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter; @@ -35,15 +32,11 @@ import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.matcher.ElementMatcher; -@AutoService(InstrumenterModule.class) -public final class RunnableFutureInstrumentation extends InstrumenterModule.Tracing +public final class RunnableFutureInstrumentation implements Instrumenter.ForBootstrap, Instrumenter.ForTypeHierarchy, Instrumenter.HasMethodAdvice, ExcludeFilterProvider { - public RunnableFutureInstrumentation() { - super(EXECUTOR_INSTRUMENTATION_NAME, "runnable-future"); - } @Override public String hierarchyMarkerType() { @@ -62,11 +55,6 @@ public ElementMatcher hierarchyMatcher() { "com.google.common.util.concurrent.TrustedListenableFutureTask")))); } - @Override - public Map contextStore() { - return singletonMap("java.util.concurrent.RunnableFuture", State.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { // instrument any FutureTask or TrustedListenableFutureTask constructor, diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/runnable/RunnableInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/runnable/RunnableInstrumentation.java index d334d5ef2d6..c00645fc19c 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/runnable/RunnableInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/runnable/RunnableInstrumentation.java @@ -4,38 +4,27 @@ import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.notExcludedByName; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType.RUNNABLE; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.RUNNABLE_INSTRUMENTATION_NAME; -import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.isPublic; import static net.bytebuddy.matcher.ElementMatchers.not; import static net.bytebuddy.matcher.ElementMatchers.takesArguments; -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.ContextStore; import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.api.AgentScope; import datadog.trace.bootstrap.instrumentation.java.concurrent.AdviceUtils; import datadog.trace.bootstrap.instrumentation.java.concurrent.State; -import java.util.Map; import java.util.concurrent.RunnableFuture; import net.bytebuddy.asm.Advice; import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.matcher.ElementMatcher; /** Instrument {@link Runnable} */ -@AutoService(InstrumenterModule.class) -public final class RunnableInstrumentation extends InstrumenterModule.Tracing +public final class RunnableInstrumentation implements Instrumenter.ForBootstrap, Instrumenter.ForTypeHierarchy, Instrumenter.HasMethodAdvice { - public RunnableInstrumentation() { - super(EXECUTOR_INSTRUMENTATION_NAME, RUNNABLE_INSTRUMENTATION_NAME); - } - @Override public String hierarchyMarkerType() { return null; // bootstrap type @@ -48,11 +37,6 @@ public ElementMatcher hierarchyMatcher() { .and(not(implementsInterface(named(RunnableFuture.class.getName())))); } - @Override - public Map contextStore() { - return singletonMap(Runnable.class.getName(), State.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice( diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/runnable/RunnableModule.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/runnable/RunnableModule.java new file mode 100644 index 00000000000..7115797b5cd --- /dev/null +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/runnable/RunnableModule.java @@ -0,0 +1,59 @@ +package datadog.trace.instrumentation.java.concurrent.runnable; + +import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; +import static java.util.Collections.singleton; + +import com.google.auto.service.AutoService; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import datadog.trace.api.InstrumenterConfig; +import datadog.trace.bootstrap.instrumentation.java.concurrent.State; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@AutoService(InstrumenterModule.class) +public class RunnableModule extends InstrumenterModule.Tracing { + final boolean runnableEnabled; + final boolean consumerTaskEnabled; + final boolean runnableFutureEnabled; + + public RunnableModule() { + super(EXECUTOR_INSTRUMENTATION_NAME); + final InstrumenterConfig config = InstrumenterConfig.get(); + runnableEnabled = config.isIntegrationEnabled(singleton("runnable"), true); + consumerTaskEnabled = config.isIntegrationEnabled(singleton("consumer-task"), true); + runnableFutureEnabled = config.isIntegrationEnabled(singleton("runnable-future"), true); + } + + @Override + public Map contextStore() { + final Map ret = new HashMap<>(); + if (runnableEnabled) { + ret.put(Runnable.class.getName(), State.class.getName()); + } + if (consumerTaskEnabled) { + ret.put("java.util.concurrent.ForkJoinTask", State.class.getName()); + } + if (runnableFutureEnabled) { + ret.put("java.util.concurrent.RunnableFuture", State.class.getName()); + } + return ret; + } + + @Override + public List typeInstrumentations() { + final List ret = new ArrayList<>(3); + if (consumerTaskEnabled) { + ret.add(new ConsumerTaskInstrumentation()); + } + if (runnableFutureEnabled) { + ret.add(new RunnableFutureInstrumentation()); + } + if (runnableEnabled) { + ret.add(new RunnableInstrumentation()); + } + return ret; + } +} diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/timer/JavaTimerInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/timer/JavaTimerInstrumentation.java index 820da7bb54a..346123825de 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/timer/JavaTimerInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/timer/JavaTimerInstrumentation.java @@ -5,41 +5,26 @@ import static datadog.trace.bootstrap.instrumentation.java.concurrent.AdviceUtils.capture; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.ExcludeType.RUNNABLE; import static datadog.trace.bootstrap.instrumentation.java.concurrent.ExcludeFilter.exclude; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.RUNNABLE_INSTRUMENTATION_NAME; -import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.isMethod; import static net.bytebuddy.matcher.ElementMatchers.isPrivate; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; import static net.bytebuddy.matcher.ElementMatchers.takesArguments; -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.ContextStore; import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.java.concurrent.State; -import java.util.Map; import java.util.TimerTask; import net.bytebuddy.asm.Advice; -@AutoService(InstrumenterModule.class) -public class JavaTimerInstrumentation extends InstrumenterModule.Tracing +public final class JavaTimerInstrumentation implements Instrumenter.ForBootstrap, Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public JavaTimerInstrumentation() { - super("java_timer", EXECUTOR_INSTRUMENTATION_NAME, RUNNABLE_INSTRUMENTATION_NAME); - } @Override public String instrumentedType() { return "java.util.Timer"; } - @Override - public Map contextStore() { - return singletonMap("java.lang.Runnable", State.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice( diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/timer/JavaTimerModule.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/timer/JavaTimerModule.java new file mode 100644 index 00000000000..0f6267ebb4f --- /dev/null +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/timer/JavaTimerModule.java @@ -0,0 +1,32 @@ +package datadog.trace.instrumentation.java.concurrent.timer; + +import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; +import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.RUNNABLE_INSTRUMENTATION_NAME; + +import com.google.auto.service.AutoService; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import datadog.trace.bootstrap.instrumentation.java.concurrent.State; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +/** Groups the instrumentations for java.util.Timer and TimerTask. */ +@AutoService(InstrumenterModule.class) +public final class JavaTimerModule extends InstrumenterModule.Tracing { + + public JavaTimerModule() { + super("java_timer", EXECUTOR_INSTRUMENTATION_NAME, RUNNABLE_INSTRUMENTATION_NAME); + } + + @Override + public Map contextStore() { + return Collections.singletonMap("java.lang.Runnable", State.class.getName()); + } + + @Override + public List typeInstrumentations() { + return Arrays.asList(new JavaTimerInstrumentation(), new TimerTaskInstrumentation()); + } +} diff --git a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/timer/TimerTaskInstrumentation.java b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/timer/TimerTaskInstrumentation.java index 7ec39f4586c..496b6d20dc8 100644 --- a/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/timer/TimerTaskInstrumentation.java +++ b/dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/timer/TimerTaskInstrumentation.java @@ -2,20 +2,14 @@ import static datadog.trace.agent.tooling.bytebuddy.matcher.HierarchyMatchers.extendsClass; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.EXECUTOR_INSTRUMENTATION_NAME; -import static datadog.trace.instrumentation.java.concurrent.ConcurrentInstrumentationNames.RUNNABLE_INSTRUMENTATION_NAME; -import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.isPublic; import static net.bytebuddy.matcher.ElementMatchers.takesArguments; -import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.InstrumentationContext; import datadog.trace.bootstrap.instrumentation.java.concurrent.AdviceUtils; import datadog.trace.bootstrap.instrumentation.java.concurrent.State; import datadog.trace.instrumentation.java.concurrent.runnable.RunnableInstrumentation; -import java.util.Map; import java.util.TimerTask; import net.bytebuddy.asm.Advice; import net.bytebuddy.description.type.TypeDescription; @@ -27,16 +21,11 @@ *

Only the cancel part is handled here because the execution is handled by the {@link * RunnableInstrumentation} */ -@AutoService(InstrumenterModule.class) -public final class TimerTaskInstrumentation extends InstrumenterModule.Tracing +public final class TimerTaskInstrumentation implements Instrumenter.ForBootstrap, Instrumenter.ForTypeHierarchy, Instrumenter.HasMethodAdvice { - public TimerTaskInstrumentation() { - super("java_timer", EXECUTOR_INSTRUMENTATION_NAME, RUNNABLE_INSTRUMENTATION_NAME); - } - @Override public String hierarchyMarkerType() { return null; // bootstrap type @@ -47,11 +36,6 @@ public ElementMatcher hierarchyMatcher() { return extendsClass(named(TimerTask.class.getName())); } - @Override - public Map contextStore() { - return singletonMap(Runnable.class.getName(), State.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice(