Adds methods for setting TagMap.Entry directly on AgentSpan/DDSpan

dd-java-agent/instrumentation-testing/src/main/groovy/datadog/trace/agent/test/TrackingSpanDecorator.groovy

@@ -114,6 +114,11 @@ class TrackingSpanDecorator implements AgentSpan {
     return delegate.setTag(key, value)
   }
 
+  @Override
+  AgentSpan setTag(TagMap.EntryReader entry) {
+    return delegate.setTag(entry)
+  }
+
   @Override
   void setRequestBlockingAction(Flow.Action.RequestBlockingAction rba) {
     delegate.setRequestBlockingAction(rba)
@@ -184,6 +189,11 @@ class TrackingSpanDecorator implements AgentSpan {
     return delegate.setMetric(key, value)
   }
 
+  @Override
+  AgentSpan setMetric(TagMap.EntryReader entry) {
+    return delegate.setMetric(entry)
+  }
+
   @Override
   boolean isError() {
     return delegate.isError()

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

@@ -392,7 +392,7 @@ private boolean isExceptionReplayEnabled() {
   public final DDSpan setTag(final String tag, final String value) {
     if (value == null || value.isEmpty()) {
       // Remove the tag
-      context.setTag(tag, null);
+      context.removeTag(tag);
     } else {
       context.setTag(tag, value);
     }
@@ -405,6 +405,12 @@ public final DDSpan setTag(final String tag, final boolean value) {
     return this;
   }
 
+  @Override
+  public final DDSpan setTag(TagMap.EntryReader entry) {
+    context.setTag(entry);
+    return this;
+  }
+
   @Override
   public void setRequestBlockingAction(Flow.Action.RequestBlockingAction rba) {
     this.requestBlockingAction = rba;
@@ -474,6 +480,12 @@ public DDSpan setMetric(final CharSequence metric, final double value) {
     return this;
   }
 
+  @Override
+  public DDSpan setMetric(TagMap.EntryReader entry) {
+    context.setMetric(entry);
+    return this;
+  }
+
   @Override
   public DDSpan setFlag(CharSequence name, boolean value) {
     context.setMetric(name, value ? 1 : 0);

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

@@ -751,6 +751,18 @@ public void setMetric(final CharSequence key, final Number value) {
     }
   }
 
+  public void setMetric(final TagMap.EntryReader entry) {
+    synchronized (unsafeTags) {
+      unsafeTags.set(entry);
+    }
+  }
+
+  public void removeTag(String tag) {
+    synchronized (unsafeTags) {
+      unsafeTags.remove(tag);
+    }
+  }
+
   /**
    * Sets a tag to the span. Tags are not propagated to the children.
    *
@@ -790,6 +802,20 @@ public void setTag(final String tag, final String value) {
     }
   }
 
+  public void setTag(TagMap.EntryReader entry) {
+    if (entry == null) return;
+
+    // prcheck to avoid boxing
+    boolean intercepted =
+        precheckIntercept(entry.tag())
+            && tagInterceptor.interceptTag(this, entry.tag(), entry.objectValue());
+    if (!intercepted) {
+      synchronized (unsafeTags) {
+        unsafeTags.set(entry);
+      }
+    }
+  }
+
   /*
    * Uses to determine if there's an opportunity to avoid primitve boxing.
    * If the underlying map doesn't support efficient primitives, then boxing is used.

dd-trace-core/src/test/java/datadog/trace/core/SpanTest.java

@@ -0,0 +1,27 @@
+package datadog.trace.core;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import datadog.trace.api.TagMap;
+import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
+import org.junit.jupiter.api.Test;
+
+public class SpanTest {
+  static final CoreTracer TRACER = CoreTracer.builder().build();
+
+  @Test
+  public void setTag_Entry() {
+    AgentSpan span = TRACER.startSpan("foo", "foo");
+    span.setTag(TagMap.Entry.create("message", "hello"));
+
+    assertEquals("hello", span.getTag("message"));
+  }
+
+  @Test
+  public void setMetric_Entry() {
+    AgentSpan span = TRACER.startSpan("foo", "foo");
+    span.setMetric(TagMap.Entry.create("metric", 20L));
+
+    assertEquals(Long.valueOf(20L), span.getTag("metric"));
+  }
+}

internal-api/src/main/java/datadog/trace/api/TagMap.java

@@ -369,6 +369,37 @@ final class Entry extends EntryChange implements Map.Entry<String, Object>, Entr
      */
     static final byte ANY = 0;
 
+    public static final Entry create(String tag, Object value) {
+      // NOTE: From the static typing, it is possible that value is a primitive box, so need to call
+      // Any variant
+      return TagMap.Entry.newAnyEntry(tag, value);
+    }
+
+    public static final Entry create(String tag, CharSequence value) {
+      // NOTE: From the static typing, we know that value is not a primitive box
+      return TagMap.Entry.newObjectEntry(tag, value);
+    }
+
+    public static final Entry create(String tag, boolean value) {
+      return TagMap.Entry.newBooleanEntry(tag, value);
+    }
+
+    public static final Entry create(String tag, int value) {
+      return TagMap.Entry.newIntEntry(tag, value);
+    }
+
+    public static final Entry create(String tag, long value) {
+      return TagMap.Entry.newLongEntry(tag, value);
+    }
+
+    public static final Entry create(String tag, float value) {
+      return TagMap.Entry.newFloatEntry(tag, value);
+    }
+
+    public static final Entry create(String tag, double value) {
+      return TagMap.Entry.newDoubleEntry(tag, value);
+    }
+
     static Entry newAnyEntry(Map.Entry<? extends String, ? extends Object> entry) {
       return newAnyEntry(entry.getKey(), entry.getValue());
     }

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

@@ -77,6 +77,8 @@ default boolean isValid() {
 
   AgentSpan setTag(String key, Object value);
 
+  AgentSpan setTag(TagMap.EntryReader entry);
+
   AgentSpan setAllTags(Map<String, ?> map);
 
   @Override
@@ -91,6 +93,8 @@ default boolean isValid() {
   @Override
   AgentSpan setMetric(CharSequence key, double value);
 
+  AgentSpan setMetric(TagMap.EntryReader metricEntry);
+
   @Override
   AgentSpan setSpanType(final CharSequence type);
 

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

@@ -1,5 +1,6 @@
 package datadog.trace.bootstrap.instrumentation.api;
 
+import datadog.trace.api.TagMap;
 import datadog.trace.api.gateway.Flow.Action.RequestBlockingAction;
 import datadog.trace.api.interceptor.MutableSpan;
 import java.util.Map;
@@ -41,6 +42,11 @@ public AgentSpan setTag(String key, String value) {
     return this;
   }
 
+  @Override
+  public AgentSpan setTag(TagMap.EntryReader entry) {
+    return this;
+  }
+
   @Override
   public AgentSpan setTag(String key, CharSequence value) {
     return this;
@@ -76,6 +82,11 @@ public AgentSpan setMetric(CharSequence key, double value) {
     return this;
   }
 
+  @Override
+  public AgentSpan setMetric(TagMap.EntryReader entry) {
+    return this;
+  }
+
   @Override
   public AgentSpan setSpanType(CharSequence type) {
     return this;