feat(core): Implement standalone ASM propagator

Author: PerfectSlayer

dd-trace-core/src/main/java/datadog/trace/core/CoreTracer.java

@@ -5,6 +5,7 @@
 import static datadog.trace.api.DDTags.DJM_ENABLED;
 import static datadog.trace.api.DDTags.DSM_ENABLED;
 import static datadog.trace.api.DDTags.PROFILING_CONTEXT_ENGINE;
+import static datadog.trace.bootstrap.instrumentation.api.AgentPropagation.STANDALONE_ASM_CONCERN;
 import static datadog.trace.bootstrap.instrumentation.api.AgentPropagation.TRACING_CONCERN;
 import static datadog.trace.bootstrap.instrumentation.api.AgentPropagation.XRAY_TRACING_CONCERN;
 import static datadog.trace.common.metrics.MetricsAggregatorFactory.createMetricsAggregator;
@@ -90,6 +91,7 @@
 import datadog.trace.core.propagation.ExtractedContext;
 import datadog.trace.core.propagation.HttpCodec;
 import datadog.trace.core.propagation.PropagationTags;
+import datadog.trace.core.propagation.StandaloneAsmPropagator;
 import datadog.trace.core.propagation.TracingPropagator;
 import datadog.trace.core.propagation.XRayPropagator;
 import datadog.trace.core.scopemanager.ContinuableScopeManager;
@@ -725,7 +727,14 @@ private CoreTracer(
     this.propagation =
         new CorePropagation(builtExtractor, injector, injectors, dataStreamContextInjector);
 
-    Propagators.register(TRACING_CONCERN, new TracingPropagator(injector, extractor));
+    // Check if standalone AppSec is enabled:
+    // If enabled, use the standalone AppSec propagator by default that will limit tracing concern
+    // injection and delegate to the tracing propagator if needed,
+    // If disabled, the most common case, use the usual tracing propagator by default.
+    boolean standaloneAppSec = config.isAppSecStandaloneEnabled();
+    Propagators.register(STANDALONE_ASM_CONCERN, new StandaloneAsmPropagator(), standaloneAppSec);
+    Propagators.register(
+        TRACING_CONCERN, new TracingPropagator(injector, extractor), !standaloneAppSec);
     Propagators.register(XRAY_TRACING_CONCERN, new XRayPropagator(config), false);
 
     this.tagInterceptor =

dd-trace-core/src/main/java/datadog/trace/core/propagation/StandaloneAsmPropagator.java

@@ -0,0 +1,40 @@
+package datadog.trace.core.propagation;
+
+import static datadog.trace.bootstrap.instrumentation.api.AgentPropagation.TRACING_CONCERN;
+import static datadog.trace.bootstrap.instrumentation.api.AgentSpan.fromContext;
+
+import datadog.context.Context;
+import datadog.context.propagation.CarrierSetter;
+import datadog.context.propagation.CarrierVisitor;
+import datadog.context.propagation.Propagator;
+import datadog.context.propagation.Propagators;
+import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
+import datadog.trace.bootstrap.instrumentation.api.AgentSpanContext;
+import datadog.trace.core.DDSpanContext;
+import javax.annotation.ParametersAreNonnullByDefault;
+
+@ParametersAreNonnullByDefault
+public class StandaloneAsmPropagator implements Propagator {
+  @Override
+  public <C> void inject(Context context, C carrier, CarrierSetter<C> setter) {
+    // Stop propagation if appsec propagation is disabled (no ASM events), stop propagation
+    AgentSpan span;
+    if ((span = fromContext(context)) != null) {
+      AgentSpanContext spanContext = span.context();
+      if (spanContext instanceof DDSpanContext) {
+        DDSpanContext ddSpanContext = (DDSpanContext) spanContext;
+        if (!ddSpanContext.getPropagationTags().isAppsecPropagationEnabled()) {
+          return;
+        }
+      }
+      // Only propagate tracing for appsec standalone product
+      Propagators.forConcern(TRACING_CONCERN).inject(span, carrier, setter);
+    }
+  }
+
+  @Override
+  public <C> Context extract(Context context, C carrier, CarrierVisitor<C> visitor) {
+    // Only propagate tracing for appsec standalone product
+    return Propagators.forConcern(TRACING_CONCERN).extract(context, carrier, visitor);
+  }
+}

dd-trace-core/src/test/groovy/datadog/trace/core/propagation/TracingPropagatorTest.groovy

@@ -156,4 +156,30 @@ class TracingPropagatorTest extends DDCoreSpecification {
     span.finish()
     tracer.close()
   }
+
+  def 'test ASM standalone billing propagator stop propagation'() {
+    setup:
+    injectSysConfig('experimental.appsec.standalone.enabled', standaloneAsmEnabled.toString())
+    def tracer = tracerBuilder().build()
+    def span = tracer.buildSpan('test', 'operation').start()
+    def setter = Mock(CarrierSetter)
+    def carrier = new Object()
+
+    when:
+    Propagators.defaultPropagator().inject(span, carrier, setter)
+
+    then:
+    if (standaloneAsmEnabled) {
+      0 * setter.set(_, _, _)
+    } else {
+      (1.._) * setter.set(_, _, _)
+    }
+
+    cleanup:
+    span.finish()
+    tracer.close()
+
+    where:
+    standaloneAsmEnabled << [true, false]
+  }
 }

internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentPropagation.java

@@ -1,5 +1,7 @@
 package datadog.trace.bootstrap.instrumentation.api;
 
+import static datadog.context.propagation.Concern.named;
+
 import datadog.context.propagation.CarrierSetter;
 import datadog.context.propagation.CarrierVisitor;
 import datadog.context.propagation.Concern;
@@ -9,8 +11,9 @@
 import javax.annotation.ParametersAreNonnullByDefault;
 
 public interface AgentPropagation {
-  Concern TRACING_CONCERN = Concern.named("tracing");
-  Concern XRAY_TRACING_CONCERN = Concern.named("tracing-xray");
+  Concern TRACING_CONCERN = named("tracing");
+  Concern XRAY_TRACING_CONCERN = named("tracing-xray");
+  Concern STANDALONE_ASM_CONCERN = named("asm-standalone");
 
   <C> void inject(AgentSpan span, C carrier, Setter<C> setter);
 

internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentSpan.java

@@ -25,7 +25,7 @@ public interface AgentSpan
    * @return the span if existing, {@code null} otherwise.
    */
   static AgentSpan fromContext(Context context) {
-    return context.get(SPAN_KEY);
+    return context == null ? null : context.get(SPAN_KEY);
   }
 
   /**