Port akka http instrumentation to instrumenter module api

dd-java-agent/instrumentation/akka/akka-actor-2.5/src/main/java/datadog/trace/instrumentation/akka/concurrent/AkkaActorCellInstrumentation.java

@@ -3,38 +3,24 @@
 import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named;
 import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.checkpointActiveForRollback;
 import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.rollbackActiveToCheckpoint;
-import static java.util.Collections.singletonMap;
 import static net.bytebuddy.matcher.ElementMatchers.isMethod;
 
 import akka.dispatch.Envelope;
-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.java.concurrent.AdviceUtils;
 import datadog.trace.bootstrap.instrumentation.java.concurrent.State;
-import java.util.Map;
 import net.bytebuddy.asm.Advice;
 
-@AutoService(InstrumenterModule.class)
-public class AkkaActorCellInstrumentation extends InstrumenterModule.Tracing
+public class AkkaActorCellInstrumentation
     implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice {
 
-  public AkkaActorCellInstrumentation() {
-    super("akka_actor_receive", "akka_actor", "akka_concurrent", "java_concurrent");
-  }
-
   @Override
   public String instrumentedType() {
     return "akka.actor.ActorCell";
   }
 
-  @Override
-  public Map<String, String> contextStore() {
-    return singletonMap("akka.dispatch.Envelope", State.class.getName());
-  }
-
   @Override
   public void methodAdvice(MethodTransformer transformer) {
     transformer.applyAdvice(

dd-java-agent/instrumentation/akka/akka-actor-2.5/src/main/java/datadog/trace/instrumentation/akka/concurrent/AkkaConcurrentModule.java

@@ -0,0 +1,58 @@
+package datadog.trace.instrumentation.akka.concurrent;
+
+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.akka.init.DisableTracingActorInitInstrumentation;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@AutoService(InstrumenterModule.class)
+public class AkkaConcurrentModule extends InstrumenterModule.Tracing {
+  public AkkaConcurrentModule() {
+    super("akka_concurrent", "java_concurrent");
+  }
+
+  @Override
+  public Map<String, String> contextStore() {
+    final Map<String, String> store = new HashMap<>();
+    store.put(Runnable.class.getName(), State.class.getName());
+    store.put("akka.dispatch.Envelope", State.class.getName());
+    store.put("akka.dispatch.forkjoin.ForkJoinTask", State.class.getName());
+    return store;
+  }
+
+  @Override
+  public List<Instrumenter> typeInstrumentations() {
+    final List<Instrumenter> instrumenters = new ArrayList<>(8);
+    // akka concurrent defaults
+    instrumenters.add(new AkkaForkJoinExecutorTaskInstrumentation());
+    instrumenters.add(new AkkaForkJoinPoolInstrumentation());
+    instrumenters.add(new AkkaForkJoinTaskInstrumentation());
+    instrumenters.add(new DisableTracingActorInitInstrumentation());
+    final InstrumenterConfig instrumenterConfig = InstrumenterConfig.get();
+    // akka actor
+    if (instrumenterConfig.isIntegrationEnabled(singleton("akka_actor"), true)) {
+      // receive
+      if (instrumenterConfig.isIntegrationEnabled(singleton("akka_actor_receive"), true)) {
+        instrumenters.add(new AkkaActorCellInstrumentation());
+      }
+      // send
+      if (instrumenterConfig.isIntegrationEnabled(singleton("akka_actor_send"), true)) {
+        instrumenters.add(new AkkaEnvelopeInstrumentation());
+        instrumenters.add(new AkkaRoutedActorCellInstrumentation());
+      }
+      // mailbox
+      if (instrumenterConfig.isIntegrationEnabled(singleton("akka_actor_mailbox"), true)) {
+        instrumenters.add(new AkkaMailboxInstrumentation());
+      }
+    }
+    return instrumenters;
+  }
+}

dd-java-agent/instrumentation/akka/akka-actor-2.5/src/main/java/datadog/trace/instrumentation/akka/concurrent/AkkaEnvelopeInstrumentation.java

@@ -1,36 +1,21 @@
 package datadog.trace.instrumentation.akka.concurrent;
 
 import static datadog.trace.bootstrap.instrumentation.java.concurrent.AdviceUtils.capture;
-import static java.util.Collections.singletonMap;
 import static net.bytebuddy.matcher.ElementMatchers.isConstructor;
 
 import akka.dispatch.Envelope;
-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.State;
-import java.util.Map;
 import net.bytebuddy.asm.Advice;
 
-@AutoService(InstrumenterModule.class)
-public class AkkaEnvelopeInstrumentation extends InstrumenterModule.Tracing
+public class AkkaEnvelopeInstrumentation
     implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice {
-
-  public AkkaEnvelopeInstrumentation() {
-    super("akka_actor_send", "akka_actor", "akka_concurrent", "java_concurrent");
-  }
-
   @Override
   public String instrumentedType() {
     return "akka.dispatch.Envelope";
   }
 
-  @Override
-  public Map<String, String> contextStore() {
-    return singletonMap("akka.dispatch.Envelope", State.class.getName());
-  }
-
   @Override
   public void methodAdvice(MethodTransformer transformer) {
     transformer.applyAdvice(isConstructor(), getClass().getName() + "$ConstructAdvice");

dd-java-agent/instrumentation/akka/akka-actor-2.5/src/main/java/datadog/trace/instrumentation/akka/concurrent/AkkaForkJoinExecutorTaskInstrumentation.java

@@ -8,35 +8,22 @@
 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.InstrumenterConfig;
 import datadog.trace.bootstrap.InstrumentationContext;
 import datadog.trace.bootstrap.instrumentation.api.AgentScope;
 import datadog.trace.bootstrap.instrumentation.java.concurrent.State;
-import java.util.Collections;
-import java.util.Map;
 import net.bytebuddy.asm.Advice;
 
 /**
  * akka.dispatch.ForkJoinExecutorConfigurator$AkkaForkJoinTask requires special treatment and can't
  * be handled generically despite being a subclass of akka.dispatch.ForkJoinTask, because of its
  * error handling.
  */
-@AutoService(InstrumenterModule.class)
-public final class AkkaForkJoinExecutorTaskInstrumentation extends InstrumenterModule.Tracing
+public final class AkkaForkJoinExecutorTaskInstrumentation
     implements Instrumenter.ForSingleType,
         Instrumenter.ForConfiguredType,
         Instrumenter.HasMethodAdvice {
-  public AkkaForkJoinExecutorTaskInstrumentation() {
-    super("java_concurrent", "akka_concurrent");
-  }
-
-  @Override
-  public Map<String, String> contextStore() {
-    return Collections.singletonMap(Runnable.class.getName(), State.class.getName());
-  }
 
   @Override
   public String instrumentedType() {

dd-java-agent/instrumentation/akka/akka-actor-2.5/src/main/java/datadog/trace/instrumentation/akka/concurrent/AkkaForkJoinPoolInstrumentation.java

@@ -5,29 +5,20 @@
 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 java.util.Collections.singletonMap;
 import static net.bytebuddy.matcher.ElementMatchers.isMethod;
 
 import akka.dispatch.forkjoin.ForkJoinTask;
-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.InstrumentationContext;
 import datadog.trace.bootstrap.instrumentation.java.concurrent.State;
-import java.util.Map;
 import net.bytebuddy.asm.Advice;
 
-@AutoService(InstrumenterModule.class)
-public final class AkkaForkJoinPoolInstrumentation extends InstrumenterModule.Tracing
+public final class AkkaForkJoinPoolInstrumentation
     implements Instrumenter.ForSingleType,
         Instrumenter.ForConfiguredType,
         Instrumenter.HasMethodAdvice {
 
-  public AkkaForkJoinPoolInstrumentation() {
-    super("java_concurrent", "akka_concurrent");
-  }
-
   @Override
   public String instrumentedType() {
     return "akka.dispatch.forkjoin.ForkJoinPool";
@@ -38,11 +29,6 @@ public String configuredMatchingType() {
     return InstrumenterConfig.get().getAkkaForkJoinPoolName();
   }
 
-  @Override
-  public Map<String, String> contextStore() {
-    return singletonMap("akka.dispatch.forkjoin.ForkJoinTask", State.class.getName());
-  }
-
   @Override
   public void methodAdvice(MethodTransformer transformer) {
     transformer.applyAdvice(

dd-java-agent/instrumentation/akka/akka-actor-2.5/src/main/java/datadog/trace/instrumentation/akka/concurrent/AkkaForkJoinTaskInstrumentation.java

@@ -11,14 +11,11 @@
 import static datadog.trace.bootstrap.instrumentation.java.concurrent.AdviceUtils.startTaskScope;
 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 java.util.Collections.singletonMap;
 import static net.bytebuddy.matcher.ElementMatchers.isMethod;
 
 import akka.dispatch.forkjoin.ForkJoinTask;
-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.InstrumenterConfig;
 import datadog.trace.bootstrap.InstrumentationContext;
 import datadog.trace.bootstrap.instrumentation.api.AgentScope;
@@ -38,19 +35,9 @@
  * <p>Note: There are quite a few separate implementations of {@code ForkJoinTask}/{@code
  * ForkJoinPool}: JVM, Akka, Scala, Netty to name a few. This class handles Akka version.
  */
-@AutoService(InstrumenterModule.class)
-public final class AkkaForkJoinTaskInstrumentation extends InstrumenterModule.Tracing
+public final class AkkaForkJoinTaskInstrumentation
     implements Instrumenter.ForTypeHierarchy, Instrumenter.HasMethodAdvice, ExcludeFilterProvider {
 
-  public AkkaForkJoinTaskInstrumentation() {
-    super("java_concurrent", "akka_concurrent");
-  }
-
-  @Override
-  public Map<String, String> contextStore() {
-    return singletonMap("akka.dispatch.forkjoin.ForkJoinTask", State.class.getName());
-  }
-
   @Override
   public String hierarchyMarkerType() {
     String akkaForkJoinTaskName = InstrumenterConfig.get().getAkkaForkJoinTaskName();

dd-java-agent/instrumentation/akka/akka-actor-2.5/src/main/java/datadog/trace/instrumentation/akka/concurrent/AkkaMailboxInstrumentation.java

@@ -6,25 +6,18 @@
 import static java.util.Collections.singletonList;
 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.instrumentation.java.concurrent.ExcludeFilter;
 import java.util.Collection;
 import java.util.EnumMap;
 import java.util.List;
 import java.util.Map;
 import net.bytebuddy.asm.Advice;
 
-@AutoService(InstrumenterModule.class)
-public class AkkaMailboxInstrumentation extends InstrumenterModule.Tracing
+public class AkkaMailboxInstrumentation
     implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice, ExcludeFilterProvider {
 
-  public AkkaMailboxInstrumentation() {
-    super("akka_actor_mailbox", "akka_actor", "akka_concurrent", "java_concurrent");
-  }
-
   @Override
   public String instrumentedType() {
     return "akka.dispatch.Mailbox";

dd-java-agent/instrumentation/akka/akka-actor-2.5/src/main/java/datadog/trace/instrumentation/akka/concurrent/AkkaRoutedActorCellInstrumentation.java

@@ -1,40 +1,26 @@
 package datadog.trace.instrumentation.akka.concurrent;
 
 import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named;
-import static java.util.Collections.singletonMap;
 import static net.bytebuddy.matcher.ElementMatchers.isMethod;
 import static net.bytebuddy.matcher.ElementMatchers.takesArgument;
 
 import akka.dispatch.Envelope;
 import akka.routing.RoutedActorCell;
-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.java.concurrent.AdviceUtils;
 import datadog.trace.bootstrap.instrumentation.java.concurrent.State;
-import java.util.Map;
 import net.bytebuddy.asm.Advice;
 
-@AutoService(InstrumenterModule.class)
-public class AkkaRoutedActorCellInstrumentation extends InstrumenterModule.Tracing
+public class AkkaRoutedActorCellInstrumentation
     implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice {
 
-  public AkkaRoutedActorCellInstrumentation() {
-    super("akka_actor_send", "akka_actor", "akka_concurrent", "java_concurrent");
-  }
-
   @Override
   public String instrumentedType() {
     return "akka.routing.RoutedActorCell";
   }
 
-  @Override
-  public Map<String, String> contextStore() {
-    return singletonMap("akka.dispatch.Envelope", State.class.getName());
-  }
-
   @Override
   public void methodAdvice(MethodTransformer transformer) {
     transformer.applyAdvice(

dd-java-agent/instrumentation/akka/akka-actor-2.5/src/main/java/datadog/trace/instrumentation/akka/init/DisableTracingActorInitInstrumentation.java

@@ -5,20 +5,13 @@
 import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.noopSpan;
 
 import akka.actor.ActorSystem$;
-import com.google.auto.service.AutoService;
 import datadog.trace.agent.tooling.Instrumenter;
-import datadog.trace.agent.tooling.InstrumenterModule;
 import datadog.trace.bootstrap.instrumentation.api.AgentScope;
 import net.bytebuddy.asm.Advice;
 
-@AutoService(InstrumenterModule.class)
-public final class DisableTracingActorInitInstrumentation extends InstrumenterModule.Tracing
+public final class DisableTracingActorInitInstrumentation
     implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice {
 
-  public DisableTracingActorInitInstrumentation() {
-    super("akka_concurrent");
-  }
-
   @Override
   public String instrumentedType() {
     return "akka.actor.ActorSystem$";

dd-java-agent/instrumentation/akka/akka-http/akka-http-10.0/src/main/java/datadog/trace/instrumentation/akkahttp/AkkaHttp2ServerInstrumentation.java

@@ -7,11 +7,7 @@
 import akka.http.scaladsl.model.HttpRequest;
 import akka.http.scaladsl.model.HttpResponse;
 import akka.stream.Materializer;
-import com.google.auto.service.AutoService;
 import datadog.trace.agent.tooling.Instrumenter;
-import datadog.trace.agent.tooling.InstrumenterModule;
-import datadog.trace.agent.tooling.muzzle.Reference;
-import datadog.trace.instrumentation.akkahttp.appsec.ScalaListCollectorMuzzleReferences;
 import net.bytebuddy.asm.Advice;
 import scala.Function1;
 import scala.concurrent.Future;
@@ -20,40 +16,14 @@
  * Http2 support in akka-http is handled by a separate {@code Http2} extension that only supports
  * {@code bindAndHandleAsync}.
  */
-@AutoService(InstrumenterModule.class)
-public final class AkkaHttp2ServerInstrumentation extends InstrumenterModule.Tracing
+public final class AkkaHttp2ServerInstrumentation
     implements Instrumenter.ForKnownTypes, Instrumenter.HasMethodAdvice {
-  public AkkaHttp2ServerInstrumentation() {
-    super("akka-http2", "akka-http", "akka-http-server");
-  }
 
   @Override
   public String[] knownMatchingTypes() {
     return new String[] {"akka.http.scaladsl.Http2Ext", "akka.http.impl.engine.http2.Http2Ext"};
   }
 
-  @Override
-  public String[] helperClassNames() {
-    return new String[] {
-      packageName + ".DatadogWrapperHelper",
-      packageName + ".DatadogAsyncHandlerWrapper",
-      packageName + ".DatadogAsyncHandlerWrapper$1",
-      packageName + ".DatadogAsyncHandlerWrapper$2",
-      packageName + ".AkkaHttpServerHeaders",
-      packageName + ".AkkaHttpServerDecorator",
-      packageName + ".RecoverFromBlockedExceptionPF",
-      packageName + ".UriAdapter",
-      packageName + ".appsec.AkkaBlockResponseFunction",
-      packageName + ".appsec.BlockingResponseHelper",
-      packageName + ".appsec.ScalaListCollector",
-    };
-  }
-
-  @Override
-  public Reference[] additionalMuzzleReferences() {
-    return ScalaListCollectorMuzzleReferences.additionalMuzzleReferences();
-  }
-
   @Override
   public void methodAdvice(MethodTransformer transformer) {
     transformer.applyAdvice(