feat(core): Exclude Dev Server and Sentry Dsn request from Breadcrumbs

CHANGELOG.md

@@ -33,6 +33,8 @@
 
 ### Fixes
 
+- Excludes Dev Server and Sentry Dsn requests from Breadcrumbs ([#4240](https://github.com/getsentry/sentry-react-native/pull/4240))
+- Prevents exception capture context from being overwritten by native scope sync ([#4124](https://github.com/getsentry/sentry-react-native/pull/4124))
 - Ignore JavascriptException to filter out obfuscated duplicate JS Errors on Android ([#4232](https://github.com/getsentry/sentry-react-native/pull/4232))
 - Skips ignoring require cycle logs for RN 0.70 or newer ([#4214](https://github.com/getsentry/sentry-react-native/pull/4214))
 - Enhanced accuracy of time-to-display spans. ([#4189](https://github.com/getsentry/sentry-react-native/pull/4189))

packages/core/RNSentryAndroidTester/app/src/androidTest/java/io/sentry/react/RNSentryModuleImplTest.kt

@@ -0,0 +1,86 @@
+package io.sentry.react
+
+import android.content.Context
+import androidx.test.platform.app.InstrumentationRegistry
+import com.facebook.react.bridge.PromiseImpl
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.soloader.SoLoader
+import io.sentry.Breadcrumb
+import io.sentry.Scope
+import io.sentry.SentryOptions
+import io.sentry.android.core.SentryAndroidOptions
+import org.junit.Assert.assertEquals
+import org.junit.Assert.fail
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(JUnit4::class)
+class RNSentryModuleImplTest {
+
+    private lateinit var module: RNSentryModuleImpl
+    private lateinit var context: Context
+
+    @Before
+    fun setUp() {
+        context = InstrumentationRegistry.getInstrumentation().targetContext
+        SoLoader.init(context, false)
+        val reactContext = ReactApplicationContext(context)
+        module = RNSentryModuleImpl(reactContext)
+    }
+
+    @Test
+    fun fetchNativeDeviceContextsWithNullContext() {
+        val options = SentryAndroidOptions()
+        val scope = Scope(options)
+        val promise = PromiseImpl({
+            assertEquals(1, it.size)
+            assertEquals(null, it[0])
+        }, {
+            fail("Promise was rejected unexpectedly")
+        })
+        module.fetchNativeDeviceContexts(promise, options, null, scope)
+    }
+
+    @Test
+    fun fetchNativeDeviceContextsWithInvalidSentryOptions() {
+        class NotAndroidSentryOptions : SentryOptions()
+
+        val options = NotAndroidSentryOptions()
+        val scope = Scope(options)
+        val promise = PromiseImpl({
+            assertEquals(1, it.size)
+            assertEquals(null, it[0])
+        }, {
+            fail("Promise was rejected unexpectedly")
+        })
+        module.fetchNativeDeviceContexts(promise, options, context, scope)
+    }
+
+    @Test
+    fun fetchNativeDeviceContextsFiltersBreadcrumbs() {
+        val options = SentryAndroidOptions().apply { maxBreadcrumbs = 5 }
+        val scope = Scope(options)
+        scope.addBreadcrumb(Breadcrumb("Breadcrumb1-RN").apply { origin = "react-native" })
+        scope.addBreadcrumb(Breadcrumb("Breadcrumb2-Native"))
+        scope.addBreadcrumb(Breadcrumb("Breadcrumb3-Native").apply { origin = "java" })
+        scope.addBreadcrumb(Breadcrumb("Breadcrumb2-RN").apply { origin = "react-native" })
+        scope.addBreadcrumb(Breadcrumb("Breadcrumb2-RN").apply { origin = "react-native" })
+
+        val promise = PromiseImpl({
+            assertEquals(1, it.size)
+            assertEquals(true, it[0] is WritableMap)
+            val actual = it[0] as WritableMap
+            val breadcrumbs = actual.getArray("breadcrumbs")
+            assertEquals(2, breadcrumbs?.size())
+            assertEquals("Breadcrumb2-Native", breadcrumbs?.getMap(0)?.getString("message"))
+            assertEquals("Breadcrumb3-Native", breadcrumbs?.getMap(1)?.getString("message"))
+        }, {
+            fail("Promise was rejected unexpectedly")
+        })
+
+        module.fetchNativeDeviceContexts(promise, options, context, scope)
+    }
+}

packages/core/RNSentryAndroidTester/app/src/test/java/io/sentry/react/RNSentryModuleImplTest.kt

@@ -8,12 +8,14 @@ import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.common.JavascriptException
+import io.sentry.Breadcrumb
 import io.sentry.ILogger
 import io.sentry.SentryLevel
 import io.sentry.android.core.SentryAndroidOptions
 import org.junit.After
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
@@ -134,4 +136,109 @@ class RNSentryModuleImplTest {
         module.getSentryAndroidOptions(actualOptions, JavaOnlyMap.of(), logger)
         assertTrue(actualOptions.ignoredExceptionsForType.contains(JavascriptException::class.java))
     }
+
+    @Test
+    fun `beforeBreadcrumb callback filters out Sentry DSN requests breadcrumbs`() {
+        val options = SentryAndroidOptions()
+        val rnOptions = JavaOnlyMap.of(
+            "dsn", "https://[email protected]/1234567",
+            "devServerUrl", "http://localhost:8081",
+        )
+        module.getSentryAndroidOptions(options, rnOptions, logger)
+
+        val breadcrumb = Breadcrumb().apply {
+            type = "http"
+            setData("url", "https://def.ingest.sentry.io/1234567")
+        }
+
+        val result = options.beforeBreadcrumb?.execute(breadcrumb, mock())
+
+        assertNull("Breadcrumb should be filtered out", result)
+    }
+
+    @Test
+    fun `beforeBreadcrumb callback filters out dev server breadcrumbs`() {
+        val mockDevServerUrl = "http://localhost:8081"
+        val options = SentryAndroidOptions()
+        val rnOptions = JavaOnlyMap.of(
+            "dsn", "https://[email protected]/1234567",
+            "devServerUrl", mockDevServerUrl,
+        )
+        module.getSentryAndroidOptions(options, rnOptions, logger)
+
+        val breadcrumb = Breadcrumb().apply {
+            type = "http"
+            setData("url", mockDevServerUrl)
+        }
+
+        val result = options.beforeBreadcrumb?.execute(breadcrumb, mock())
+
+        assertNull("Breadcrumb should be filtered out", result)
+    }
+
+    @Test
+    fun `beforeBreadcrumb callback does not filter out non dev server or dsn breadcrumbs`() {
+        val options = SentryAndroidOptions()
+        val rnOptions = JavaOnlyMap.of(
+            "dsn", "https://[email protected]/1234567",
+            "devServerUrl", "http://localhost:8081",
+        )
+        module.getSentryAndroidOptions(options, rnOptions, logger)
+
+        val breadcrumb = Breadcrumb().apply {
+            type = "http"
+            setData("url", "http://testurl.com/service")
+        }
+
+        val result = options.beforeBreadcrumb?.execute(breadcrumb, mock())
+
+        assertEquals(breadcrumb, result)
+    }
+
+    @Test
+    fun `the breadcrumb is not filtered out when the dev server url and dsn are not passed`() {
+        val options = SentryAndroidOptions()
+        module.getSentryAndroidOptions(options, JavaOnlyMap(), logger)
+
+        val breadcrumb = Breadcrumb().apply {
+            type = "http"
+            setData("url", "http://testurl.com/service")
+        }
+
+        val result = options.beforeBreadcrumb?.execute(breadcrumb, mock())
+
+        assertEquals(breadcrumb, result)
+    }
+
+    @Test
+    fun `the breadcrumb is not filtered out when the dev server url is not passed and the dsn does not match`() {
+        val options = SentryAndroidOptions()
+        val rnOptions = JavaOnlyMap.of("dsn", "https://[email protected]/1234567")
+        module.getSentryAndroidOptions(options, rnOptions, logger)
+
+        val breadcrumb = Breadcrumb().apply {
+            type = "http"
+            setData("url", "http://testurl.com/service")
+        }
+
+        val result = options.beforeBreadcrumb?.execute(breadcrumb, mock())
+
+        assertEquals(breadcrumb, result)
+    }
+
+    @Test
+    fun `the breadcrumb is not filtered out when the dev server url does not match and the dsn is not passed`() {
+        val options = SentryAndroidOptions()
+        val rnOptions = JavaOnlyMap.of("devServerUrl", "http://localhost:8081")
+        module.getSentryAndroidOptions(options, rnOptions, logger)
+
+        val breadcrumb = Breadcrumb().apply {
+            type = "http"
+            setData("url", "http://testurl.com/service")
+        }
+
+        val result = options.beforeBreadcrumb?.execute(breadcrumb, mock())
+
+        assertEquals(breadcrumb, result)
+    }
 }

packages/core/RNSentryAndroidTester/app/src/test/java/io/sentry/rnsentryandroidtester/RNSentryBreadcrumbTest.kt

@@ -1,6 +1,7 @@
 package io.sentry.rnsentryandroidtester
 
 import com.facebook.react.bridge.JavaOnlyMap
+import io.sentry.SentryLevel
 import io.sentry.react.RNSentryBreadcrumb
 import junit.framework.TestCase.assertEquals
 import org.junit.Test
@@ -10,6 +11,38 @@ import org.junit.runners.JUnit4
 @RunWith(JUnit4::class)
 class RNSentryBreadcrumbTest {
 
+    @Test
+    fun generatesSentryBreadcrumbFromMap() {
+        val testData = JavaOnlyMap.of(
+            "test", "data",
+        )
+        val map = JavaOnlyMap.of(
+            "level", "error",
+            "category", "testCategory",
+            "origin", "testOrigin",
+            "type", "testType",
+            "message", "testMessage",
+            "data", testData,
+        )
+        val actual = RNSentryBreadcrumb.fromMap(map)
+        assertEquals(SentryLevel.ERROR, actual.level)
+        assertEquals("testCategory", actual.category)
+        assertEquals("testOrigin", actual.origin)
+        assertEquals("testType", actual.type)
+        assertEquals("testMessage", actual.message)
+        assertEquals(testData.toHashMap(), actual.data)
+    }
+
+    @Test
+    fun reactNativeForMissingOrigin() {
+        val map = JavaOnlyMap.of(
+            "message", "testMessage",
+        )
+        val actual = RNSentryBreadcrumb.fromMap(map)
+        assertEquals("testMessage", actual.message)
+        assertEquals("react-native", actual.origin)
+    }
+
     @Test
     fun nullForMissingCategory() {
         val map = JavaOnlyMap.of()

packages/core/RNSentryCocoaTester/RNSentryCocoaTester.xcodeproj/project.pbxproj

@@ -13,6 +13,7 @@
 		33AFDFED2B8D14B300AAB120 /* RNSentryFramesTrackerListenerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 33AFDFEC2B8D14B300AAB120 /* RNSentryFramesTrackerListenerTests.m */; };
 		33AFDFF12B8D15E500AAB120 /* RNSentryDependencyContainerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 33AFDFF02B8D15E500AAB120 /* RNSentryDependencyContainerTests.m */; };
 		33F58AD02977037D008F60EA /* RNSentryTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 33F58ACF2977037D008F60EA /* RNSentryTests.mm */; };
+		AEFB00422CC90C4B00EC8A9A /* RNSentryBreadcrumbTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 3360843C2C340C76008CC412 /* RNSentryBreadcrumbTests.swift */; };
 		B5859A50A3E865EF5E61465A /* libPods-RNSentryCocoaTesterTests.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 650CB718ACFBD05609BF2126 /* libPods-RNSentryCocoaTesterTests.a */; };
 /* End PBXBuildFile section */
 
@@ -221,6 +222,7 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				AEFB00422CC90C4B00EC8A9A /* RNSentryBreadcrumbTests.swift in Sources */,
 				332D33472CDBDBB600547D76 /* RNSentryReplayOptionsTests.swift in Sources */,
 				33AFDFF12B8D15E500AAB120 /* RNSentryDependencyContainerTests.m in Sources */,
 				336084392C32E382008CC412 /* RNSentryReplayBreadcrumbConverterTests.swift in Sources */,

packages/core/RNSentryCocoaTester/RNSentryCocoaTesterTests/RNSentryBreadcrumbTests.swift

@@ -1,12 +1,13 @@
 import XCTest
 import Sentry
 
-class RNSentryBreadcrumbTests: XCTestCase {
+final class RNSentryBreadcrumbTests: XCTestCase {
 
     func testGeneratesSentryBreadcrumbFromNSDictionary() {
         let actualCrumb = RNSentryBreadcrumb.from([
             "level": "error",
             "category": "testCategory",
+            "origin": "testOrigin",
             "type": "testType",
             "message": "testMessage",
             "data": [
@@ -16,11 +17,29 @@ class RNSentryBreadcrumbTests: XCTestCase {
 
         XCTAssertEqual(actualCrumb!.level, SentryLevel.error)
         XCTAssertEqual(actualCrumb!.category, "testCategory")
+        XCTAssertEqual(actualCrumb!.origin, "testOrigin")
         XCTAssertEqual(actualCrumb!.type, "testType")
         XCTAssertEqual(actualCrumb!.message, "testMessage")
         XCTAssertEqual((actualCrumb!.data)!["test"] as! String, "data")
     }
 
+    func testUsesReactNativeAsDefaultOrigin() {
+        let actualCrumb = RNSentryBreadcrumb.from([
+            "message": "testMessage"
+        ])
+
+        XCTAssertEqual(actualCrumb!.origin, "react-native")
+    }
+
+    func testKeepsOriginIfSet() {
+        let actualCrumb = RNSentryBreadcrumb.from([
+            "message": "testMessage",
+            "origin": "someOrigin"
+        ])
+
+        XCTAssertEqual(actualCrumb!.origin, "someOrigin")
+    }
+
     func testUsesInfoAsDefaultSentryLevel() {
         let actualCrumb = RNSentryBreadcrumb.from([
             "message": "testMessage"