Support addEvent Otel API

dd-java-agent/agent-otel/otel-shim/build.gradle

@@ -6,6 +6,8 @@ minimumBranchCoverage = 0.0
 dependencies {
   // minimum OpenTelemetry API version this shim is compatible with
   compileOnly group: 'io.opentelemetry', name: 'opentelemetry-api', version: '1.4.0'
+  implementation 'org.jetbrains:annotations:24.0.0'
+  implementation 'com.squareup.moshi:moshi:1.15.0'
 
   implementation project(':internal-api')
 }

dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/trace/OtelConventions.java

@@ -14,10 +14,12 @@
 import static java.lang.Boolean.parseBoolean;
 import static java.util.Locale.ROOT;
 
+import datadog.trace.api.DDTags;
 import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
 import datadog.trace.bootstrap.instrumentation.api.Tags;
 import io.opentelemetry.api.common.AttributeKey;
 import io.opentelemetry.api.trace.SpanKind;
+import java.util.List;
 import javax.annotation.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -122,6 +124,13 @@ public static void applyNamingConvention(AgentSpan span) {
     }
   }
 
+  public static void setEventsAsTag(AgentSpan span, List<SpanEvent> events) {
+    if (events == null || events.isEmpty()) {
+      return;
+    }
+    span.setTag(DDTags.SPAN_EVENTS, SpanEvent.toTag(events));
+  }
+
   private static String computeOperationName(AgentSpan span) {
     Object spanKingTag = span.getTag(SPAN_KIND);
     SpanKind spanKind =

dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/trace/OtelSpan.java

@@ -2,6 +2,7 @@
 
 import static datadog.opentelemetry.shim.trace.OtelConventions.applyNamingConvention;
 import static datadog.opentelemetry.shim.trace.OtelConventions.applyReservedAttribute;
+import static datadog.opentelemetry.shim.trace.OtelConventions.setEventsAsTag;
 import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan;
 import static io.opentelemetry.api.trace.StatusCode.ERROR;
 import static io.opentelemetry.api.trace.StatusCode.OK;
@@ -18,6 +19,7 @@
 import io.opentelemetry.api.trace.StatusCode;
 import io.opentelemetry.api.trace.TraceFlags;
 import io.opentelemetry.api.trace.TraceState;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import javax.annotation.ParametersAreNonnullByDefault;
@@ -27,6 +29,7 @@ public class OtelSpan implements Span {
   private final AgentSpan delegate;
   private StatusCode statusCode;
   private boolean recording;
+  private List<SpanEvent> events;
 
   public OtelSpan(AgentSpan delegate) {
     this.delegate = delegate;
@@ -71,13 +74,23 @@ public <T> Span setAttribute(AttributeKey<T> key, T value) {
 
   @Override
   public Span addEvent(String name, Attributes attributes) {
-    // Not supported
+    if (this.recording) {
+      if (this.events == null || this.events.isEmpty()) {
+        this.events = new ArrayList<>();
+      }
+      this.events.add(new SpanEvent(name, attributes));
+    }
     return this;
   }
 
   @Override
   public Span addEvent(String name, Attributes attributes, long timestamp, TimeUnit unit) {
-    // Not supported
+    if (this.recording) {
+      if (this.events == null || this.events.isEmpty()) {
+        this.events = new ArrayList<>();
+      }
+      this.events.add(new SpanEvent(name, attributes, timestamp, unit));
+    }
     return this;
   }
 
@@ -118,13 +131,15 @@ public Span updateName(String name) {
   public void end() {
     this.recording = false;
     applyNamingConvention(this.delegate);
+    setEventsAsTag(this.delegate, this.events);
     this.delegate.finish();
   }
 
   @Override
   public void end(long timestamp, TimeUnit unit) {
     this.recording = false;
     applyNamingConvention(this.delegate);
+    setEventsAsTag(this.delegate, this.events);
     this.delegate.finish(unit.toMicros(timestamp));
   }
 

dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/trace/SpanEvent.java

@@ -0,0 +1,100 @@
+package datadog.opentelemetry.shim.trace;
+
+import com.squareup.moshi.FromJson;
+import com.squareup.moshi.JsonAdapter;
+import com.squareup.moshi.Moshi;
+import com.squareup.moshi.ToJson;
+import io.opentelemetry.api.common.Attributes;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import org.jetbrains.annotations.NotNull;
+
+public class SpanEvent {
+
+  private final long timestamp;
+  private final String name;
+  // attributes
+
+  public SpanEvent(String name, Attributes attributes) {
+    this.name = name;
+    this.timestamp = timeNano();
+  }
+
+  public SpanEvent(String name, Attributes attributes, long timestamp, TimeUnit unit) {
+    this.name = name;
+    this.timestamp = timeNano(timestamp, unit);
+  }
+
+  private static long timeNano() {
+    return System.nanoTime();
+  }
+
+  private static long timeNano(long timestamp, TimeUnit unit) {
+    return TimeUnit.NANOSECONDS.convert(timestamp, unit);
+  }
+
+  public String toString() {
+    // TODO if attributes exist, process those
+    return "{\"name\":\"" + this.name + "\",\"time_unix_nano\":" + this.timestamp + "}";
+  }
+
+  @NotNull
+  public static String toTag(List<SpanEvent> events) {
+    StringBuilder builder = new StringBuilder("[");
+    int index = 0;
+    while (index < events.size()) {
+      String linkAsJson = getEncoder().toJson(events.get(index));
+      if (index > 0) {
+        builder.append(',');
+      }
+      builder.append(linkAsJson);
+      index++;
+    }
+    // TODO: Do we want to enforce a maximum tag size, like TAG_MAX_LENGTH in DDSpanLink? If so,
+    // should this limit exist in DDTags instead (to apply to all tags moving forward)?
+    // If so, then we can maybe share the json encoder code between SpanEvent and DDSpanLink classes
+    return builder.append("]").toString();
+  }
+
+  private static JsonAdapter<SpanEvent> getEncoder() {
+    return EncoderHolder.ENCODER;
+  }
+
+  private static class EncoderHolder {
+    static final JsonAdapter<SpanEvent> ENCODER = createEncoder();
+
+    private static JsonAdapter<SpanEvent> createEncoder() {
+      Moshi moshi = new Moshi.Builder().add(new SpanEventAdapter()).build();
+      return moshi.adapter(SpanEvent.class);
+    }
+  }
+
+  private static class SpanEventAdapter {
+    @ToJson
+    SpanEventJson toSpanEventJson(SpanEvent event) {
+      SpanEventJson json = new SpanEventJson();
+      json.name = event.name;
+      json.time_unix_nano = event.timestamp;
+      //      if (!link.attributes().isEmpty()) {
+      //        json.attributes = link.attributes().asMap();
+      //      }
+      return json;
+    }
+
+    @FromJson
+    SpanEvent fromSpanEventJson(SpanEventJson json) {
+      return new SpanEvent(
+          json.name,
+          // attributes
+          null,
+          json.time_unix_nano,
+          TimeUnit.NANOSECONDS);
+    }
+  }
+
+  private static class SpanEventJson {
+    String name;
+    long time_unix_nano;
+    //    Map<String, String> attributes;
+  }
+}

dd-java-agent/instrumentation/opentelemetry/opentelemetry-1.4/src/test/groovy/OpenTelemetry14Test.groovy

@@ -15,6 +15,8 @@ import org.skyscreamer.jsonassert.JSONAssert
 import spock.lang.Subject
 
 import java.security.InvalidParameterException
+import java.sql.Time
+import java.util.concurrent.TimeUnit
 
 import static datadog.trace.api.DDTags.ERROR_MSG
 import static datadog.trace.bootstrap.instrumentation.api.Tags.SPAN_KIND
@@ -33,6 +35,9 @@ import static io.opentelemetry.api.trace.StatusCode.OK
 import static io.opentelemetry.api.trace.StatusCode.UNSET
 
 class OpenTelemetry14Test extends AgentTestRunner {
+  static final TIME_MILLIS = 1723220824705
+  static final TIME_NANO = TIME_MILLIS * 1_000_000L
+
   @Subject
   def tracer = GlobalOpenTelemetry.get().tracerProvider.get("some-instrumentation")
 
@@ -175,29 +180,100 @@ class OpenTelemetry14Test extends AgentTestRunner {
     }
   }
 
-  def "test non-supported features do not crash"() {
+  def "test add single event"() {
     setup:
     def builder = tracer.spanBuilder("some-name")
-    def anotherSpan = tracer.spanBuilder("another-name").startSpan()
-    anotherSpan.end()
 
     when:
-    // Adding event is not supported
     def result = builder.startSpan()
-    result.addEvent("some-event")
+    result.addEvent(name, timestamp, unit)
     result.end()
 
     then:
-    assertTraces(2) {
+    long expectTime = timestamp
+    if (unit == TimeUnit.MILLISECONDS) {
+      expectTime *= 1_000_000L
+    }
+
+    def expectedEventTag = """
+    [
+      { "name": "${name}",
+        "time_unix_nano": ${expectTime}}
+    ]"""
+    assertTraces(1) {
       trace(1) {
-        span {}
+        span {
+          tags {
+            defaultTags()
+            "$SPAN_KIND" "$SPAN_KIND_INTERNAL"
+            tag("events", { JSONAssert.assertEquals(expectedEventTag, it as String, false); return true })
+          }
+        }
+      }
+    }
+
+    where:
+    name   | attributes | timestamp   | unit
+    "evt2" | null       | TIME_MILLIS | TimeUnit.MILLISECONDS
+    "evt3" | null       | TIME_NANO   | TimeUnit.NANOSECONDS
+  }
+
+  def "test multiple span events"() {
+    setup:
+    def builder = tracer.spanBuilder("some-name")
+
+    when:
+    def result = builder.startSpan()
+    result.addEvent(name, timestamp, TimeUnit.NANOSECONDS)
+    result.addEvent(name, timestamp, TimeUnit.NANOSECONDS)
+    result.end()
+
+    then:
+    def expectedEventTag = """
+    [
+      { "name": "${name}",
+        "time_unix_nano": ${timestamp}
+      },
+      { "name": "${name}",
+        "time_unix_nano": ${timestamp}
       }
+    ]"""
+    assertTraces(1) {
       trace(1) {
-        span {}
+        span {
+          tags {
+            defaultTags()
+            "$SPAN_KIND" "$SPAN_KIND_INTERNAL"
+            tag("events", { JSONAssert.assertEquals(expectedEventTag, it as String, false); return true })
+          }
+        }
       }
     }
+    where:
+    name   | timestamp | attributes
+    "evt1" | TIME_NANO | null
+    "evt2" | TIME_NANO | null
   }
 
+  //  def "test add event no timestamp"() {
+  //    setup:
+  //    def builder = tracer.spanBuilder("some-name")
+  //
+  //    when:
+  //    def result = builder.startSpan()
+  //    result.addEvent("evt", null, null)
+  //    result.end()
+  //
+  //    then:
+  //    long endBlock = System.nanoTime();
+  //
+  //    // I'd like to grab the span's `time_unix_nano` field under `events` tag is not null, and is more than beforeBlock and less than afterBlock
+  //    // But I don't know how to access this without asserting the span tags look a specific way using assertTraces.
+  //
+  //    where:
+  //    long startBlock = System.nanoTime();
+  //  }
+
   def "test simple span links"() {
     setup:
     def traceId = "1234567890abcdef1234567890abcdef" as String

dd-trace-api/src/main/java/datadog/trace/api/DDTags.java

@@ -59,6 +59,7 @@ public class DDTags {
   public static final String LANGUAGE_TAG_VALUE = "jvm";
   public static final String ORIGIN_KEY = "_dd.origin";
   public static final String SPAN_LINKS = "_dd.span_links";
+  public static final String SPAN_EVENTS = "events";
   public static final String LIBRARY_VERSION_TAG_KEY = "library_version";
   public static final String CI_ENV_VARS = "_dd.ci.env_vars";
   public static final String CI_ITR_TESTS_SKIPPED = "_dd.ci.itr.tests_skipped";