Merge branch 'main' into fix/fewer-npes

Author: adinauer

.github/workflows/system-tests-backend.yml

@@ -101,7 +101,7 @@ jobs:
 
       - name: Start server and run integration test for sentry-cli commands
         run: |
-          test/system-test-run.sh "${{ matrix.sample }}" "${{ matrix.agent }}" "${{ matrix.agent-auto-init }}"
+          test/system-test-run.sh "${{ matrix.sample }}" "${{ matrix.agent }}" "${{ matrix.agent-auto-init }}" "0"
 
       - name: Upload test results
         if: always()

.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

@@ -1,5 +1,7 @@
 # Changelog
 
+## Unreleased
+
 ### Fixes
 
 - The SDK now handles `null` on many APIs instead of expecting a non `null` value ([#4245](https://github.com/getsentry/sentry-java/pull/4245))
@@ -8,16 +10,30 @@
   - If `null` is passed, the SDK will
     - do nothing if a `null` key is passed, returning `null` for non void methods
     - replace any previous value if the new value is set to `null`
+- Add support for setting in-app-includes/in-app-excludes via AndroidManifest.xml ([#4240](https://github.com/getsentry/sentry-java/pull/4240))
+- Modifications to OkHttp requests are now properly propagated to the affected span / breadcrumbs ([#4238](https://github.com/getsentry/sentry-java/pull/4238))
+  - Please ensure the SentryOkHttpInterceptor is added last to your OkHttpClient, as otherwise changes to the `Request`  by subsequent interceptors won't be considered
 
 ### 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
 
 - 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)
 
+### Internal
+
+- 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
 
 - Bump Native SDK from v0.7.20 to v0.8.1 ([#4137](https://github.com/getsentry/sentry-java/pull/4137))

build.gradle.kts

@@ -155,7 +155,7 @@ subprojects {
         }
     }
 
-    if (!this.name.contains("sample") && !this.name.contains("integration-tests") && this.name != "sentry-test-support" && this.name != "sentry-compose-helper") {
+    if (!this.name.contains("sample") && !this.name.contains("integration-tests") && this.name != "sentry-system-test-support" && this.name != "sentry-test-support" && this.name != "sentry-compose-helper") {
         apply<DistributionPlugin>()
         apply<com.vanniktech.maven.publish.MavenPublishPlugin>()
 

buildSrc/src/main/java/Config.kt

@@ -75,6 +75,7 @@ object Config {
         val log4j2Core = "org.apache.logging.log4j:log4j-core:$log4j2Version"
 
         val jacksonDatabind = "com.fasterxml.jackson.core:jackson-databind"
+        val jacksonKotlin = "com.fasterxml.jackson.module:jackson-module-kotlin:2.18.3"
 
         val springBootStarter = "org.springframework.boot:spring-boot-starter:$springBootVersion"
         val springBootStarterGraphql = "org.springframework.boot:spring-boot-starter-graphql:$springBootVersion"

codecov.yml

@@ -16,5 +16,6 @@ coverage:
 ignore:
   - "**/src/test/*"
   - "sentry-android-integration-tests/*"
+  - "sentry-system-test-support/*"
   - "sentry-test-support/*"
   - "sentry-samples/*"

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-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpEvent.kt

@@ -28,28 +28,59 @@ internal class SentryOkHttpEvent(private val scopes: IScopes, private val reques
     private var response: Response? = null
     private var clientErrorResponse: Response? = null
     private val isEventFinished = AtomicBoolean(false)
-    private val url: String
-    private val method: String
+    private var url: String
+    private var method: String
 
     init {
         val urlDetails = UrlUtils.parse(request.url.toString())
         url = urlDetails.urlOrFallback
-        val host: String = request.url.host
-        val encodedPath: String = request.url.encodedPath
         method = request.method
 
         // We start the call span that will contain all the others
         val parentSpan = if (Platform.isAndroid()) scopes.transaction else scopes.span
-        callSpan = parentSpan?.startChild("http.client", "$method $url")
+        callSpan = parentSpan?.startChild("http.client")
         callSpan?.spanContext?.origin = TRACE_ORIGIN
+
+        breadcrumb = Breadcrumb().apply {
+            type = "http"
+            category = "http"
+            // needs this as unix timestamp for rrweb
+            setData(
+                SpanDataConvention.HTTP_START_TIMESTAMP,
+                CurrentDateProvider.getInstance().currentTimeMillis
+            )
+        }
+
+        setRequest(request)
+    }
+
+    /**
+     * Sets the request.
+     * This function may be called multiple times in case the request changes e.g. due to interceptors.
+     */
+    fun setRequest(request: Request) {
+        val urlDetails = UrlUtils.parse(request.url.toString())
+        url = urlDetails.urlOrFallback
+
+        val host: String = request.url.host
+        val encodedPath: String = request.url.encodedPath
+        method = request.method
+
+        callSpan?.description = "$method $url"
         urlDetails.applyToSpan(callSpan)
 
-        // We setup a breadcrumb with all meaningful data
-        breadcrumb = Breadcrumb.http(url, method)
         breadcrumb.setData("host", host)
         breadcrumb.setData("path", encodedPath)
-        // needs this as unix timestamp for rrweb
-        breadcrumb.setData(SpanDataConvention.HTTP_START_TIMESTAMP, CurrentDateProvider.getInstance().currentTimeMillis)
+        if (urlDetails.url != null) {
+            breadcrumb.setData("url", urlDetails.url!!)
+        }
+        breadcrumb.setData("method", method.uppercase())
+        if (urlDetails.query != null) {
+            breadcrumb.setData("http.query", urlDetails.query!!)
+        }
+        if (urlDetails.fragment != null) {
+            breadcrumb.setData("http.fragment", urlDetails.fragment!!)
+        }
 
         // We add the same data to the call span
         callSpan?.setData("url", url)

sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt

@@ -81,6 +81,7 @@ public open class SentryOkHttpInterceptor(
             val parentSpan = if (Platform.isAndroid()) scopes.transaction else scopes.span
             span = parentSpan?.startChild("http.client", "$method $url")
         }
+
         val startTimestamp = CurrentDateProvider.getInstance().currentTimeMillis
 
         span?.spanContext?.origin = TRACE_ORIGIN
@@ -141,6 +142,10 @@ public open class SentryOkHttpInterceptor(
             }
             throw e
         } finally {
+            // interceptors may change the request details, so let's update it here
+            // this only works correctly if SentryOkHttpInterceptor is the last one in the chain
+            okHttpEvent?.setRequest(request)
+
             finishSpan(span, request, response, isFromEventListener, okHttpEvent)
 
             // The SentryOkHttpEventListener will send the breadcrumb itself if used for this call