Merge branch 'main' into feat/consider-port-for-is-internal-span-check

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

@@ -2,20 +2,29 @@
 
 ## Unreleased
 
-### Internal
+### Behavioural Changes
 
-- Also use port when checking if a request is made to Sentry DSN ([#4231](https://github.com/getsentry/sentry-java/pull/4231))
-  - For our OpenTelemetry integration we check if a span is for a request to Sentry
-  - We now also consider the port when performing this check
+- Use `java.net.URI` for parsing URLs in `UrlUtils` ([#4210](https://github.com/getsentry/sentry-java/pull/4210))
+  - This could affect grouping for issues with messages containing URLs that fall in known corner cases that were handled incorrectly previously (e.g. email in URL path)
+
+### Fixes
+
+- Add support for setting in-app-includes/in-app-excludes via AndroidManifest.xml ([#4240](https://github.com/getsentry/sentry-java/pull/4240))
 
 ### 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
+### Internal
 
-- Use `java.net.URI` for parsing URLs in `UrlUtils` ([#4210](https://github.com/getsentry/sentry-java/pull/4210))
-  - This could affect grouping for issues with messages containing URLs that fall in known corner cases that were handled incorrectly previously (e.g. email in URL path)
+- Also use port when checking if a request is made to Sentry DSN ([#4231](https://github.com/getsentry/sentry-java/pull/4231))
+  - For our OpenTelemetry integration we check if a span is for a request to Sentry
+  - We now also consider the port when performing this check
 
 ### Dependencies
 

sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java

@@ -107,6 +107,10 @@ final class ManifestMetadataReader {
 
   static final String IGNORED_ERRORS = "io.sentry.ignored-errors";
 
+  static final String IN_APP_INCLUDES = "io.sentry.in-app-includes";
+
+  static final String IN_APP_EXCLUDES = "io.sentry.in-app-excludes";
+
   static final String ENABLE_AUTO_TRACE_ID_GENERATION =
       "io.sentry.traces.enable-auto-id-generation";
 
@@ -414,8 +418,21 @@ static void applyMetadata(
             .setMaskAllImages(readBool(metadata, logger, REPLAYS_MASK_ALL_IMAGES, true));
 
         options.setIgnoredErrors(readList(metadata, logger, IGNORED_ERRORS));
-      }
 
+        final @Nullable List<String> includes = readList(metadata, logger, IN_APP_INCLUDES);
+        if (includes != null && !includes.isEmpty()) {
+          for (final @NotNull String include : includes) {
+            options.addInAppInclude(include);
+          }
+        }
+
+        final @Nullable List<String> excludes = readList(metadata, logger, IN_APP_EXCLUDES);
+        if (excludes != null && !excludes.isEmpty()) {
+          for (final @NotNull String exclude : excludes) {
+            options.addInAppExclude(exclude);
+          }
+        }
+      }
       options
           .getLogger()
           .log(SentryLevel.INFO, "Retrieving configuration from AndroidManifest.xml");

sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt

@@ -1447,4 +1447,54 @@ class ManifestMetadataReaderTest {
         // Assert
         assertEquals(listOf(FilterString("Some error"), FilterString("Another .*")), fixture.options.ignoredErrors)
     }
+
+    @Test
+    fun `applyMetadata reads inAppIncludes to options and sets the value if found`() {
+        // Arrange
+        val bundle = bundleOf(ManifestMetadataReader.IN_APP_INCLUDES to "com.example.package1,com.example.package2")
+        val context = fixture.getContext(metaData = bundle)
+
+        // Act
+        ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+        // Assert
+        assertEquals(listOf("com.example.package1", "com.example.package2"), fixture.options.inAppIncludes)
+    }
+
+    @Test
+    fun `applyMetadata reads inAppIncludes to options and keeps empty if not found`() {
+        // Arrange
+        val context = fixture.getContext()
+
+        // Act
+        ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+        // Assert
+        assertTrue(fixture.options.inAppIncludes.isEmpty())
+    }
+
+    @Test
+    fun `applyMetadata reads inAppExcludes to options and sets the value if found`() {
+        // Arrange
+        val bundle = bundleOf(ManifestMetadataReader.IN_APP_EXCLUDES to "com.example.excluded1,com.example.excluded2")
+        val context = fixture.getContext(metaData = bundle)
+
+        // Act
+        ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+        // Assert
+        assertEquals(listOf("com.example.excluded1", "com.example.excluded2"), fixture.options.inAppExcludes)
+    }
+
+    @Test
+    fun `applyMetadata reads inAppExcludes to options and keeps empty if not found`() {
+        // Arrange
+        val context = fixture.getContext()
+
+        // Act
+        ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+        // Assert
+        assertTrue(fixture.options.inAppExcludes.isEmpty())
+    }
 }

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());
     }