Capture OpenTelemetry span events (#3564)

* capture otel events

* Set trace for captured error; set timestamp; refactor

* changelog

* fix external option name

* remove duplicate dependency entry

* ignore buildSrc/.kotlin

Author: adinauer

.gitignore

@@ -20,3 +20,4 @@ distributions/
 sentry-spring-boot-starter-jakarta/src/main/resources/META-INF/spring.factories
 sentry-samples/sentry-samples-spring-boot-jakarta/spy.log
 spy.log
+buildSrc/.kotlin/

CHANGELOG.md

@@ -9,6 +9,11 @@
 ### Features
 
 - The SDK now automatically propagates the trace-context to the native layer. This allows to connect errors on different layers of the application. ([#4137](https://github.com/getsentry/sentry-java/pull/4137))
+- Capture OpenTelemetry span events ([#3564](https://github.com/getsentry/sentry-java/pull/3564))
+  - OpenTelemetry spans may have exceptions attached to them (`openTelemetrySpan.recordException`). We can now send those to Sentry as errors.
+  - Set `capture-open-telemetry-events=true` in `sentry.properties` to enable it
+  - Set `sentry.capture-open-telemetry-events=true` in Springs `application.properties` to enable it
+  - Set `sentry.captureOpenTelemetryEvents: true` in Springs `application.yml` to enable it
 
 ### Behavioural Changes
 

sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/OtelSentrySpanProcessor.java

@@ -8,18 +8,25 @@
 import io.opentelemetry.sdk.trace.ReadWriteSpan;
 import io.opentelemetry.sdk.trace.ReadableSpan;
 import io.opentelemetry.sdk.trace.SpanProcessor;
+import io.opentelemetry.sdk.trace.data.EventData;
+import io.opentelemetry.sdk.trace.data.ExceptionEventData;
 import io.sentry.Baggage;
+import io.sentry.DateUtils;
 import io.sentry.IScopes;
 import io.sentry.PropagationContext;
 import io.sentry.ScopesAdapter;
 import io.sentry.Sentry;
 import io.sentry.SentryDate;
+import io.sentry.SentryEvent;
 import io.sentry.SentryLevel;
 import io.sentry.SentryLongDate;
 import io.sentry.SentryTraceHeader;
 import io.sentry.SpanId;
 import io.sentry.TracesSamplingDecision;
+import io.sentry.exception.ExceptionMechanismException;
+import io.sentry.protocol.Mechanism;
 import io.sentry.protocol.SentryId;
+import java.util.List;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -143,9 +150,46 @@ public void onEnd(final @NotNull ReadableSpan spanBeingEnded) {
       final @NotNull SentryDate finishDate =
           new SentryLongDate(spanBeingEnded.toSpanData().getEndEpochNanos());
       sentrySpan.updateEndDate(finishDate);
+
+      maybeCaptureSpanEventsAsExceptions(spanBeingEnded, sentrySpan);
     }
   }
 
+  private void maybeCaptureSpanEventsAsExceptions(
+      final @NotNull ReadableSpan spanBeingEnded, final @NotNull IOtelSpanWrapper sentrySpan) {
+    final @NotNull IScopes spanScopes = sentrySpan.getScopes();
+    if (spanScopes.getOptions().isCaptureOpenTelemetryEvents()) {
+      final @NotNull List<EventData> events = spanBeingEnded.toSpanData().getEvents();
+      for (EventData event : events) {
+        if (event instanceof ExceptionEventData) {
+          final @NotNull ExceptionEventData exceptionEvent = (ExceptionEventData) event;
+          captureException(spanScopes, exceptionEvent, sentrySpan);
+        }
+      }
+    }
+  }
+
+  private void captureException(
+      final @NotNull IScopes scopes,
+      final @NotNull ExceptionEventData exceptionEvent,
+      final @NotNull IOtelSpanWrapper sentrySpan) {
+    final @NotNull Throwable exception = exceptionEvent.getException();
+    final Mechanism mechanism = new Mechanism();
+    mechanism.setType("OpenTelemetrySpanEvent");
+    mechanism.setHandled(true);
+    // This is potentially the wrong Thread as it's the current thread meaning the thread where
+    // the span is being ended on. This may not match the thread where the exception occurred.
+    final Throwable mechanismException =
+        new ExceptionMechanismException(mechanism, exception, Thread.currentThread());
+
+    final SentryEvent event = new SentryEvent(mechanismException);
+    event.setTimestamp(DateUtils.nanosToDate(exceptionEvent.getEpochNanos()));
+    event.setLevel(SentryLevel.ERROR);
+    event.getContexts().setTrace(sentrySpan.getSpanContext());
+
+    scopes.captureEvent(event);
+  }
+
   @Override
   public boolean isEndRequired() {
     return true;

sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt

@@ -182,6 +182,7 @@ class SentryAutoConfigurationTest {
             "sentry.spotlight-connection-url=http://local.sentry.io:1234",
             "sentry.force-init=true",
             "sentry.global-hub-mode=true",
+            "sentry.capture-open-telemetry-events=true",
             "sentry.cron.default-checkin-margin=10",
             "sentry.cron.default-max-runtime=30",
             "sentry.cron.default-timezone=America/New_York",
@@ -222,6 +223,7 @@ class SentryAutoConfigurationTest {
             assertThat(options.isEnableBackpressureHandling).isEqualTo(false)
             assertThat(options.isForceInit).isEqualTo(true)
             assertThat(options.isGlobalHubMode).isEqualTo(true)
+            assertThat(options.isCaptureOpenTelemetryEvents).isEqualTo(true)
             assertThat(options.isEnableSpotlight).isEqualTo(true)
             assertThat(options.spotlightConnectionUrl).isEqualTo("http://local.sentry.io:1234")
             assertThat(options.cron).isNotNull

sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt

@@ -181,6 +181,7 @@ class SentryAutoConfigurationTest {
             "sentry.spotlight-connection-url=http://local.sentry.io:1234",
             "sentry.force-init=true",
             "sentry.global-hub-mode=true",
+            "sentry.capture-open-telemetry-events=true",
             "sentry.cron.default-checkin-margin=10",
             "sentry.cron.default-max-runtime=30",
             "sentry.cron.default-timezone=America/New_York",
@@ -221,6 +222,7 @@ class SentryAutoConfigurationTest {
             assertThat(options.isEnableBackpressureHandling).isEqualTo(false)
             assertThat(options.isForceInit).isEqualTo(true)
             assertThat(options.isGlobalHubMode).isEqualTo(true)
+            assertThat(options.isCaptureOpenTelemetryEvents).isEqualTo(true)
             assertThat(options.isEnableSpotlight).isEqualTo(true)
             assertThat(options.spotlightConnectionUrl).isEqualTo("http://local.sentry.io:1234")
             assertThat(options.cron).isNotNull

sentry/api/sentry.api

@@ -479,6 +479,7 @@ public final class io/sentry/ExternalOptions {
 	public fun getTags ()Ljava/util/Map;
 	public fun getTracePropagationTargets ()Ljava/util/List;
 	public fun getTracesSampleRate ()Ljava/lang/Double;
+	public fun isCaptureOpenTelemetryEvents ()Ljava/lang/Boolean;
 	public fun isEnableBackpressureHandling ()Ljava/lang/Boolean;
 	public fun isEnablePrettySerializationOutput ()Ljava/lang/Boolean;
 	public fun isEnableSpotlight ()Ljava/lang/Boolean;
@@ -487,6 +488,7 @@ public final class io/sentry/ExternalOptions {
 	public fun isGlobalHubMode ()Ljava/lang/Boolean;
 	public fun isSendDefaultPii ()Ljava/lang/Boolean;
 	public fun isSendModules ()Ljava/lang/Boolean;
+	public fun setCaptureOpenTelemetryEvents (Ljava/lang/Boolean;)V
 	public fun setCron (Lio/sentry/SentryOptions$Cron;)V
 	public fun setDebug (Ljava/lang/Boolean;)V
 	public fun setDist (Ljava/lang/String;)V
@@ -2930,6 +2932,7 @@ public class io/sentry/SentryOptions {
 	public fun isAttachServerName ()Z
 	public fun isAttachStacktrace ()Z
 	public fun isAttachThreads ()Z
+	public fun isCaptureOpenTelemetryEvents ()Z
 	public fun isDebug ()Z
 	public fun isEnableAppStartProfiling ()Z
 	public fun isEnableAutoSessionTracking ()Z
@@ -2967,6 +2970,7 @@ public class io/sentry/SentryOptions {
 	public fun setBeforeSendReplay (Lio/sentry/SentryOptions$BeforeSendReplayCallback;)V
 	public fun setBeforeSendTransaction (Lio/sentry/SentryOptions$BeforeSendTransactionCallback;)V
 	public fun setCacheDirPath (Ljava/lang/String;)V
+	public fun setCaptureOpenTelemetryEvents (Z)V
 	public fun setConnectionStatusProvider (Lio/sentry/IConnectionStatusProvider;)V
 	public fun setConnectionTimeoutMillis (I)V
 	public fun setCron (Lio/sentry/SentryOptions$Cron;)V

sentry/src/main/java/io/sentry/ExternalOptions.java

@@ -53,6 +53,7 @@ public final class ExternalOptions {
   private @Nullable Boolean enableBackpressureHandling;
   private @Nullable Boolean globalHubMode;
   private @Nullable Boolean forceInit;
+  private @Nullable Boolean captureOpenTelemetryEvents;
 
   private @Nullable SentryOptions.Cron cron;
 
@@ -146,6 +147,9 @@ public final class ExternalOptions {
 
     options.setGlobalHubMode(propertiesProvider.getBooleanProperty("global-hub-mode"));
 
+    options.setCaptureOpenTelemetryEvents(
+        propertiesProvider.getBooleanProperty("capture-open-telemetry-events"));
+
     for (final String ignoredExceptionType :
         propertiesProvider.getList("ignored-exceptions-for-type")) {
       try {
@@ -504,4 +508,14 @@ public void setEnableSpotlight(final @Nullable Boolean enableSpotlight) {
   public void setSpotlightConnectionUrl(final @Nullable String spotlightConnectionUrl) {
     this.spotlightConnectionUrl = spotlightConnectionUrl;
   }
+
+  @ApiStatus.Experimental
+  public void setCaptureOpenTelemetryEvents(final @Nullable Boolean captureOpenTelemetryEvents) {
+    this.captureOpenTelemetryEvents = captureOpenTelemetryEvents;
+  }
+
+  @ApiStatus.Experimental
+  public @Nullable Boolean isCaptureOpenTelemetryEvents() {
+    return captureOpenTelemetryEvents;
+  }
 }

sentry/src/main/java/io/sentry/SentryOptions.java

@@ -530,6 +530,7 @@ public class SentryOptions {
 
   private @NotNull SentryReplayOptions sessionReplay;
 
+  @ApiStatus.Experimental private boolean captureOpenTelemetryEvents = false;
   /**
    * Adds an event processor
    *
@@ -2634,6 +2635,16 @@ public void setSessionReplay(final @NotNull SentryReplayOptions sessionReplayOpt
     this.sessionReplay = sessionReplayOptions;
   }
 
+  @ApiStatus.Experimental
+  public void setCaptureOpenTelemetryEvents(final boolean captureOpenTelemetryEvents) {
+    this.captureOpenTelemetryEvents = captureOpenTelemetryEvents;
+  }
+
+  @ApiStatus.Experimental
+  public boolean isCaptureOpenTelemetryEvents() {
+    return captureOpenTelemetryEvents;
+  }
+
   /**
    * Load the lazy fields. Useful to load in the background, so that results are already cached. DO
    * NOT CALL THIS METHOD ON THE MAIN THREAD.
@@ -2927,7 +2938,9 @@ public void merge(final @NotNull ExternalOptions options) {
     if (options.isSendDefaultPii() != null) {
       setSendDefaultPii(options.isSendDefaultPii());
     }
-
+    if (options.isCaptureOpenTelemetryEvents() != null) {
+      setCaptureOpenTelemetryEvents(options.isCaptureOpenTelemetryEvents());
+    }
     if (options.isEnableSpotlight() != null) {
       setEnableSpotlight(options.isEnableSpotlight());
     }

sentry/src/test/java/io/sentry/ExternalOptionsTest.kt

@@ -361,6 +361,20 @@ class ExternalOptionsTest {
         }
     }
 
+    @Test
+    fun `creates options with captureOpenTelemetryEvents set to false`() {
+        withPropertiesFile("capture-open-telemetry-events=false") { options ->
+            assertTrue(options.isCaptureOpenTelemetryEvents == false)
+        }
+    }
+
+    @Test
+    fun `creates options with captureOpenTelemetryEvents set to true`() {
+        withPropertiesFile("capture-open-telemetry-events=true") { options ->
+            assertTrue(options.isCaptureOpenTelemetryEvents == true)
+        }
+    }
+
     private fun withPropertiesFile(textLines: List<String> = emptyList(), logger: ILogger = mock(), fn: (ExternalOptions) -> Unit) {
         // create a sentry.properties file in temporary folder
         val temporaryFolder = TemporaryFolder()