feat(core): Introduce tracing propagator

Author: PerfectSlayer

components/context/src/main/java/datadog/context/propagation/CarrierSetter.java

@@ -1,7 +1,5 @@
 package datadog.context.propagation;
 
-import javax.annotation.Nullable;
-
 @FunctionalInterface
 public interface CarrierSetter<C> {
   /**
@@ -11,5 +9,5 @@ public interface CarrierSetter<C> {
    * @param key the key to set.
    * @param value the value to set.
    */
-  void set(@Nullable C carrier, String key, String value);
+  void set(C carrier, String key, String value);
 }

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

@@ -18,6 +18,7 @@
 import datadog.communication.ddagent.SharedCommunicationObjects;
 import datadog.communication.monitor.Monitoring;
 import datadog.communication.monitor.Recording;
+import datadog.context.propagation.Propagators;
 import datadog.trace.api.ClassloaderConfigurationOverrides;
 import datadog.trace.api.Config;
 import datadog.trace.api.DDSpanId;
@@ -86,6 +87,7 @@
 import datadog.trace.core.propagation.ExtractedContext;
 import datadog.trace.core.propagation.HttpCodec;
 import datadog.trace.core.propagation.PropagationTags;
+import datadog.trace.core.propagation.TracingPropagator;
 import datadog.trace.core.scopemanager.ContinuableScopeManager;
 import datadog.trace.core.taginterceptor.RuleFlags;
 import datadog.trace.core.taginterceptor.TagInterceptor;
@@ -719,6 +721,8 @@ private CoreTracer(
     this.propagation =
         new CorePropagation(builtExtractor, injector, injectors, dataStreamContextInjector);
 
+    Propagators.register(TracingPropagator.concern(), new TracingPropagator(injector, extractor));
+
     this.tagInterceptor =
         null == tagInterceptor ? new TagInterceptor(new RuleFlags(config)) : tagInterceptor;
 

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

@@ -0,0 +1,65 @@
+package datadog.trace.core.propagation;
+
+import static datadog.trace.bootstrap.instrumentation.api.AgentSpan.fromSpanContext;
+
+import datadog.context.Context;
+import datadog.context.propagation.CarrierSetter;
+import datadog.context.propagation.CarrierVisitor;
+import datadog.context.propagation.Concern;
+import datadog.context.propagation.Propagator;
+import datadog.trace.bootstrap.instrumentation.api.AgentPropagation;
+import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
+import datadog.trace.bootstrap.instrumentation.api.AgentSpanContext;
+import datadog.trace.bootstrap.instrumentation.api.TagContext;
+import datadog.trace.core.DDSpanContext;
+import javax.annotation.ParametersAreNonnullByDefault;
+
+// TODO Javadoc
+@ParametersAreNonnullByDefault
+public class TracingPropagator implements Propagator {
+  private static final Concern TRACING_CONCERN = Concern.named("tracing");
+  private final HttpCodec.Injector injector;
+  private final HttpCodec.Extractor extractor;
+
+  // TODO Javadoc
+  public TracingPropagator(HttpCodec.Injector injector, HttpCodec.Extractor extractor) {
+    this.injector = injector;
+    this.extractor = extractor;
+  }
+
+  // TODO Javadoc
+  public static Concern concern() {
+    return TRACING_CONCERN;
+  }
+
+  @Override
+  public <C> void inject(Context context, C carrier, CarrierSetter<C> setter) {
+    //noinspection ConstantValue
+    if (context == null || carrier == null || setter == null) {
+      return;
+    }
+    AgentSpan span = AgentSpan.fromContext(context);
+    if (span != null) {
+      AgentSpanContext spanContext = span.context();
+      if (spanContext instanceof DDSpanContext) {
+        DDSpanContext ddSpanContext = (DDSpanContext) context;
+        injector.inject(ddSpanContext, carrier, setter::set);
+      }
+    }
+  }
+
+  @Override
+  public <C> Context extract(Context context, C carrier, CarrierVisitor<C> visitor) {
+    //noinspection ConstantValue
+    if (context == null || carrier == null || visitor == null) {
+      return context;
+    }
+    TagContext spanContext = this.extractor.extract(carrier, toContextVisitor(visitor));
+    return context.with(fromSpanContext(spanContext));
+  }
+
+  private static <C> AgentPropagation.ContextVisitor<C> toContextVisitor(CarrierVisitor<C> visitor) {
+    return (carrier1, classifier) -> visitor.forEachKeyValue(carrier1, classifier::accept);
+  }
+  private static <C> AgentPropagation.ContextVisitor<C> toContextVisitor(
+      CarrierVisitor<C> visitor) {

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

@@ -1,7 +1,11 @@
 package datadog.trace.bootstrap.instrumentation.api;
 
+import datadog.context.propagation.CarrierSetter;
+import datadog.context.propagation.CarrierVisitor;
 import datadog.trace.api.TracePropagationStyle;
 import java.util.LinkedHashMap;
+import java.util.function.BiConsumer;
+import javax.annotation.ParametersAreNonnullByDefault;
 
 public interface AgentPropagation {
   <C> void inject(AgentSpan span, C carrier, Setter<C> setter);
@@ -25,7 +29,7 @@ <C> void injectPathwayContext(
   <C> void injectPathwayContextWithoutSendingStats(
       AgentSpan span, C carrier, Setter<C> setter, LinkedHashMap<String, String> sortedTags);
 
-  interface Setter<C> {
+  interface Setter<C> extends CarrierSetter<C> {
     void set(C carrier, String key, String value);
   }
 
@@ -35,7 +39,18 @@ interface KeyClassifier {
     boolean accept(String key, String value);
   }
 
-  interface ContextVisitor<C> {
+  interface ContextVisitor<C> extends CarrierVisitor<C> {
     void forEachKey(C carrier, KeyClassifier classifier);
+
+    @ParametersAreNonnullByDefault
+    @Override
+    default void forEachKeyValue(C carrier, BiConsumer<String, String> visitor) {
+      forEachKey(
+          carrier,
+          (key, value) -> {
+            visitor.accept(key, value);
+            return true;
+          });
+    }
   }
 }

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

@@ -10,11 +10,26 @@
 import datadog.trace.api.gateway.IGSpanInfo;
 import datadog.trace.api.gateway.RequestContext;
 import datadog.trace.api.interceptor.MutableSpan;
+import datadog.trace.bootstrap.instrumentation.api.AgentTracer.NoopAgentSpan;
+import datadog.trace.bootstrap.instrumentation.api.AgentTracer.NoopContext;
 import javax.annotation.Nullable;
 
 public interface AgentSpan
     extends MutableSpan, ImplicitContextKeyed, Context, IGSpanInfo, WithAgentSpan {
 
+  // TODO Javadoc
+  static AgentSpan fromContext(Context context) {
+    return context.get(SPAN_KEY);
+  }
+
+  // TODO Javadoc
+  static AgentSpan fromSpanContext(AgentSpanContext spanContext) {
+    if (spanContext == null || spanContext == NoopContext.INSTANCE) {
+      return NoopAgentSpan.INSTANCE;
+    }
+    return new AgentTracer.ExtractedSpan(spanContext);
+  }
+
   DDTraceId getTraceId();
 
   long getSpanId();

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

@@ -584,6 +584,30 @@ public AgentSpanContext context() {
     }
   }
 
+  // TODO Support more behavior like tags edit
+  static final class ExtractedSpan extends AgentTracer.NoopAgentSpan {
+    private final AgentSpanContext spanContext;
+
+    ExtractedSpan(AgentSpanContext spanContext) {
+      this.spanContext = spanContext;
+    }
+
+    @Override
+    public DDTraceId getTraceId() {
+      return this.spanContext.getTraceId();
+    }
+
+    @Override
+    public long getSpanId() {
+      return this.spanContext.getSpanId();
+    }
+
+    @Override
+    public AgentSpanContext context() {
+      return this.spanContext;
+    }
+  }
+
   public static class NoopAgentSpan implements AgentSpan {
     public static final NoopAgentSpan INSTANCE = new NoopAgentSpan();